health-data-standards 2.2.1 → 3.0.3

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

@@ -0,0 +1,188 @@
+module HQMF
+  
+  # preconditions can be in several places.
+  #
+  # precondition -> preconditions
+  # restriction -> preconditions
+  #
+  # also, restrictions can be on the following, which can then have preconditions
+  #   restrictions
+  #   comparisons
+  #   preconditions
+  #
+  class PreconditionExtractor
+   
+   
+    def self.extract_preconditions_from_restrictions(restrictions,data_criteria_converter)
+      return [] unless restrictions
+      preconditions = []
+      restrictions.each do |restriction|
+        preconditions.concat(extract_preconditions_from_restriction(restriction,data_criteria_converter))
+      end
+      preconditions      
+    end
+    
+    # get all the preconditions for a restriction
+    # we need to iterate down 
+    #   restriction.preconditions
+    #   restriction.comparison
+    #   restriction.restriction
+    def self.extract_preconditions_from_restriction(restriction,data_criteria_converter)
+      target_id=nil
+      if restriction[:target_id] and data_criteria_converter.v1_data_criteria_by_id[restriction[:target_id]]
+        target_id = data_criteria_converter.v1_data_criteria_by_id[restriction[:target_id]].id
+      elsif restriction[:target_id]
+        puts "\tPrecondition Data Criteria MISSING: #{restriction[:target_id]}"
+      end
+      type = restriction[:type]
+      if (restriction[:negation]) 
+        inverted = HQMF::TemporalReference::INVERSION[type] 
+        if (inverted)
+          type = inverted
+        else
+          puts "\tdon't know how to invert #{type}"
+        end
+      end
+      
+      # if we reference the measurement period, then we want to check if the reference is to the start or end of the measurement period
+      # if we SBS of the END of the measurement period, we want to convert that to SBE of the measurement period
+      if target_id == HQMF::Document::MEASURE_PERIOD_ID
+        references_start = {'SBS'=>'SBE','SAS'=>'SAE','EBS'=>'EBE','EAS'=>'EAE'}
+        references_end = {'EBE'=>'EBS','EAE'=>'EAS','SBE'=>'SBS','SAE'=>'SAS'}
+        if data_criteria_converter.measure_period_v1_keys[:measure_start] == restriction[:target_id] and references_end[type]
+          # before or after the END of the measurement period START.  Convert to before or after the START of the measurement period.
+          # SAE of MPS => SAS of MP
+          type = references_end[type]
+        elsif data_criteria_converter.measure_period_v1_keys[:measure_end] == restriction[:target_id] and references_start[type]
+          # before or after the START of the measurement period END.  Convert to before or after the END of the measurement period.
+          # SBS of MPE => SBE of MP
+          type = references_start[type]
+        end
+      end
+      
+      value = nil
+      if (restriction[:range])
+        value = HQMF::Range.from_json(JSON.parse(restriction[:range].to_json)) if (restriction[:range])
+      elsif(restriction[:value])
+        value = HQMF::Converter::SimpleOperator.parse_value(restriction[:value])
+      end
+      field = restriction[:field]
+      field_code = restriction[:field_code]
+      field_time = restriction[:field_time]
+      operator = HQMF::Converter::SimpleOperator.new(HQMF::Converter::SimpleOperator.find_category(type), type, value, field, field_code, field_time)
+      
+      # get the precondtions off of the restriction
+      children = HQMF::PreconditionConverter.parse_and_merge_preconditions(restriction[:preconditions],data_criteria_converter) if restriction[:preconditions]
+      
+      if restriction[:comparison]
+        children ||= []
+        # check comparison and convert it to a precondition
+        comparison = convert_comparison_to_precondition(restriction[:comparison], data_criteria_converter)
+        children << comparison
+      end
+      
+      # check restrictions
+      restrictions = extract_preconditions_from_restrictions(restriction[:restrictions], data_criteria_converter) if restriction[:restrictions]
+      if (children)
+        HQMF::PreconditionConverter.apply_restrictions_to_comparisons(children, restrictions) unless restrictions.nil? or restrictions.empty?
+      end
+      
+      
+      container = nil
+      # check if there is an expression on the restriction
+      if (restriction[:expression])
+        # this is for things like TIMEDIFF
+        type = restriction[:expression][:type]
+        exp_operator = HQMF::Converter::SimpleOperator.new(HQMF::Converter::SimpleOperator.find_category(type), type, HQMF::Converter::SimpleOperator.parse_value(restriction[:expression][:value]))
+        preconditions = []
+        
+        driv_preconditions = []
+        restrictions.each {|element| driv_preconditions << element if element.is_a? HQMF::Converter::SimpleRestriction and element.operator.type == 'DRIV'}
+        
+        if driv_preconditions and !driv_preconditions.empty?
+          preconditions = driv_preconditions.map(&:preconditions).flatten
+        end
+      
+        reference = nil
+        conjunction_code = nil
+        
+        comparison_precondition = HQMF::Converter::SimplePrecondition.new(nil,[HQMF::Converter::SimpleRestriction.new(exp_operator, nil, preconditions)],reference,conjunction_code, false)
+        comparison_precondition.klass = HQMF::Converter::SimplePrecondition::COMPARISON
+
+        comparison_precondition.subset_comparison = true
+        container = HQMF::Converter::SimpleRestriction.new(operator, nil, [comparison_precondition])
+      
+      # check if there is a subset on the restriction
+      elsif restriction[:subset]
+        # if we have a subset, we want to create a Comparison Precondition for the subset and have it be the child of the operator on the restriction.
+        # the reason for this is that we want the order of operations to be SBS the FIRST of a data criteria, rather than FIRST of SBS of a data criteria
+        
+        subset_type = restriction[:subset]
+        subset_operator = HQMF::Converter::SimpleOperator.new(HQMF::Converter::SimpleOperator.find_category(subset_type), subset_type, nil)
+        
+        reference = nil
+        conjunction_code = nil
+        
+        restriction = HQMF::Converter::SimpleRestriction.new(subset_operator, target_id)
+        restriction.preconditions = children
+        
+        comparison_precondition = HQMF::Converter::SimplePrecondition.new(nil, [restriction], reference, conjunction_code, false)
+        comparison_precondition.klass = HQMF::Converter::SimplePrecondition::COMPARISON
+        
+        container = HQMF::Converter::SimpleRestriction.new(operator, nil, [comparison_precondition])
+      else
+        container = HQMF::Converter::SimpleRestriction.new(operator, target_id)
+        container.preconditions = children
+      end
+      
+      [container]
+    end
+
+
+    # we want the comparisons to be converted to the leaf preconditions
+    def self.convert_comparison_to_precondition(comparison, data_criteria_converter)
+
+      data_criteria = data_criteria_converter.v1_data_criteria_by_id[comparison[:data_criteria_id]]
+      reference = HQMF::Reference.new(data_criteria.id)
+#      conjunction_code = "#{data_criteria.type.to_s.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }}Reference"
+      conjunction_code = nil
+
+      preconditions = []
+      if comparison[:restrictions]
+         # check for preconditions on restrictions
+         preconditions = extract_preconditions_from_restrictions(comparison[:restrictions], data_criteria_converter) 
+      end
+      
+      precondition = HQMF::Converter::SimplePrecondition.new(nil,preconditions,reference,conjunction_code, false)
+      precondition.klass = HQMF::Converter::SimplePrecondition::COMPARISON
+      
+      if (comparison[:subset])
+        # create a restriction for a comparison subset... this is for things like first, second, etc.
+        type = comparison[:subset]
+        operator = HQMF::Converter::SimpleOperator.new(HQMF::Converter::SimpleOperator.find_category(type), type, nil)
+        restriction = HQMF::Converter::SimpleRestriction.new(operator, reference.id, nil)
+        precondition.preconditions ||= []
+        precondition.preconditions << restriction
+      end
+
+      precondition
+    end
+    
+    # flatten a tree of preconditions into an array... if we are doing something like a count, we just want the flat list
+    def self.flatten_v2_preconditions(preconditions)
+      flattened = []
+      preconditions.each do |precondition|
+        if (precondition.reference and precondition.has_preconditions?)
+          raise "don't know how to handle a condition with a reference that has preconditions" if (precondition.reference and precondition.has_preconditions?)
+        end
+        if (precondition.reference) 
+          flattened << precondition
+        else
+          flattened.concat(flatten_v2_preconditions(precondition.preconditions))
+        end
+      end
+      flattened
+    end
+    
+  end  
+end

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

@@ -0,0 +1,26 @@
+module HQMF
+  
+  module Converter
+  
+    class SimpleDataCriteria < HQMF::DataCriteria
+
+      attr_accessor :precondition_id
+
+      def self.from_data_criteria(data_criteria)
+        HQMF::Converter::SimpleDataCriteria.new(data_criteria.id, data_criteria.title, data_criteria.display_name, data_criteria.description, data_criteria.code_list_id, 
+          data_criteria.children_criteria, data_criteria.derivation_operator, data_criteria.definition,data_criteria.status, data_criteria.value, data_criteria.field_values, 
+          data_criteria.effective_time, data_criteria.inline_code_list,data_criteria.negation,data_criteria.negation_code_list_id,data_criteria.temporal_references, data_criteria.subset_operators, data_criteria.specific_occurrence,data_criteria.specific_occurrence_const)
+      end
+
+      def assign_precondition(precondtion_id)
+        return if (@precondtion_id == precondtion_id)
+        raise "Cannot assign a second precondition to a data criteria" if @precondition_id
+        @precondition_id = precondtion_id
+        @id = "#{@id}_precondition_#{precondtion_id}"
+      end
+      
+    end
+  end
+  
+  
+end

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

@@ -0,0 +1,89 @@
+module HQMF
+  
+  module Converter
+  
+    class SimpleOperator
+      
+      TEMPORAL = 'TEMPORAL'
+      SUMMARY = 'SUMMARY'
+      UNKNOWN = 'UNKNOWN'
+      
+      VALUE_FIELD_TIMES = {
+        'FACILITY_LOCATION_START' => 'FACILITY_LOCATION_ARRIVAL_DATETIME',
+        'FACILITY_LOCATION_END' => 'FACILITY_LOCATION_DEPARTURE_DATETIME'
+      }
+      
+
+      attr_accessor :type, :value, :category, :field, :field_code, :field_time
+
+      def initialize(category, type, value, field = nil, field_code=nil, field_time=nil)
+        @category = category
+        @type = type
+        @value = value
+        @field = field
+        @field_code = field_code
+        @field_time = field_time
+      end
+      
+      def temporal?
+        category == TEMPORAL
+      end
+      def summary?
+        category == SUMMARY
+      end
+      
+      def to_json
+        json = {}
+        json[:category] = @category if @category
+        json[:type] = @type if @type
+        json[:field] = @field if @field
+        json[:field_code] = @field_code if @field_code
+        json[:value] = @value.to_json if @value
+        json
+      end
+      
+      def field_value_key
+        key = HQMF::DataCriteria::VALUE_FIELDS[field_code]
+        key = VALUE_FIELD_TIMES["#{key}_#{field_time.to_s.upcase}"] if (field_time) 
+        raise "unsupported field value: #{field_code}, #{field}" unless key
+        key
+      end
+
+      def self.parse_value(value)
+        return nil unless value
+        return value if value.is_a? String
+        if (value[:value])
+          # values should be inclusive since we will be asking if it equals the value, ranther than being part of a range
+          # if it's an offset we do not care that it is inclusive
+          val = HQMF::Value.from_json(JSON.parse(value.to_json))
+          val.inclusive=true
+          val
+        elsif (value[:high] or value[:low])
+          HQMF::Range.from_json(JSON.parse(value.to_json))
+        elsif (value[:type] == 'CD')
+          HQMF::Coded.from_json(JSON.parse(value.to_json))
+        elsif (value[:type] == 'ANYNonNull')
+          HQMF::AnyValue.from_json(JSON.parse(value.to_json))
+        else
+          raise "Unexpected value format: #{value.to_json}"
+        end
+      end
+      
+      def self.find_category(type)
+        return TEMPORAL if HQMF::TemporalReference::TYPES.include? type
+        return SUMMARY if HQMF::SubsetOperator::TYPES.include? type
+        return UNKNOWN
+      end
+
+
+
+    end
+    
+    
+    
+  end
+  
+
+
+  
+end

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

@@ -0,0 +1,10 @@
+module HQMF
+  
+  module Converter
+  
+    class SimplePopulationCriteria < HQMF::PopulationCriteria
+      attr_accessor :stratification_id
+
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module HQMF
+  
+  module Converter
+  
+    class SimplePrecondition < HQMF::Precondition
+
+      COMPARISON = "COMPARISON"
+      PRECONDITION = "PRECONDITION"
+
+      attr_accessor :klass, :processed, :subset_comparison, :conjunction_code
+
+      def initialize(id, preconditions,reference,conjunction_code,negation)
+        super(id, preconditions,reference,conjunction_code,negation)
+        @id = HQMF::Counter.instance.next if (@id.nil?)
+        @klass = PRECONDITION
+      end
+      
+      def to_json
+        json = super
+#        json[:klass] = @klass
+        json
+      end
+      
+      def comparison?
+        @klass == COMPARISON
+      end
+      def restriction?
+        false
+      end
+      
+      def has_preconditions?
+        preconditions and !preconditions.empty?
+      end
+      
+      def restrictions
+        preconditions.select {|precondition| precondition.restriction?}
+      end
+      
+      def reference=(reference)
+        @reference = reference
+      end
+      
+      def delete_converted_restrictions!
+        preconditions.delete_if {|precondition| precondition.restriction? and precondition.converted}
+      end
+      
+    end
+  end
+  
+  
+end

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

@@ -0,0 +1,64 @@
+module HQMF
+  
+  module Converter
+  
+    class SimpleRestriction
+
+      include HQMF::Conversion::Utilities
+    
+      attr_accessor :operator, :target, :preconditions, :negation, :converted, :generated_data_criteria
+      def initialize(operator, target, preconditions = [])
+        @operator = operator
+        @target = target
+        @preconditions = preconditions
+      end
+    
+      # Create a new population criteria from a JSON hash keyed off symbols
+      def self.from_json(json)
+        raise "not implemented"
+      end
+      
+      def klass
+        "RESTRICTION"
+      end
+      
+      def comparison?
+        false
+      end
+      def restriction?
+        true
+      end
+
+      def has_preconditions?
+        preconditions and !preconditions.empty?
+      end
+      
+      def single_target?
+        !target.nil?
+      end
+      def multi_target?
+        has_preconditions?
+      end
+      
+      def restrictions
+        preconditions.select {|precondition| precondition.restriction?}
+      end
+      
+      def to_json
+        x = nil
+        json = {}
+        json[:klass] = klass
+        json[:operator] = @operator.to_json if @operator
+        json[:target] = @target if @target
+        json[:negation] = @negation if @negation
+        if (@preconditions)
+          json[:preconditions] = x if x = json_array(@preconditions)
+        end
+        json
+      end
+    
+    end
+  end
+  
+  
+end

data/lib/hqmf-parser/converter/pass2/comparison_converter.rb

@@ -0,0 +1,112 @@
+module HQMF
+  # Class for converting an HQMF 1.0 representation to an HQMF 2.0 representation
+  class ComparisonConverter
+    
+    def initialize(data_criteria_converter)
+      @data_criteria_converter = data_criteria_converter
+    end
+   
+    def convert_comparisons(population_criteria)
+      population_criteria.each do |population|
+        is_observation = population.type == HQMF::PopulationCriteria::OBSERV
+        walk_up_tree(population.preconditions)
+        rewrite_observation(population) if is_observation
+      end
+    end
+   
+    def walk_up_tree(preconditions)
+      preconditions.each do |precondition|
+        if (has_child_comparison(precondition))
+          walk_up_tree(precondition.preconditions)
+        end
+        if (precondition.comparison? && !precondition.processed)
+          new_data_criteria = nil
+          # duplicate the data criteria referenced by the comparision (unless it's the measurement period. we don't modify the measurement period)
+          if precondition.reference and precondition.reference.id != HQMF::Document::MEASURE_PERIOD_ID
+            data_criteria = @data_criteria_converter.v2_data_criteria_by_id[precondition.reference.id] 
+            new_data_criteria = @data_criteria_converter.duplicate_data_criteria(data_criteria, precondition.id)
+            precondition.reference.id = new_data_criteria.id
+          end
+          # add restrictions to the duplicated data criteria
+          if precondition.has_preconditions?
+            restrictions = precondition.restrictions
+            # we want to process summary operators first since they can create new data criteria
+            restrictions.sort! {|left, right| (right.operator.summary? and !left.operator.summary?) ? 1 : 0 }
+            restrictions.each do |restriction|
+              operator = restriction.operator
+              # check if the data criteria has been changed by either a grouping addition or an operator
+              if (precondition.reference and (new_data_criteria == nil or new_data_criteria.id != precondition.reference.id))
+                new_data_criteria = @data_criteria_converter.v2_data_criteria_by_id[precondition.reference.id] 
+              end
+              if (operator.temporal?)
+                HQMF::OperatorConverter.apply_temporal(new_data_criteria, precondition, restriction, @data_criteria_converter)
+              elsif(operator.summary?)
+                HQMF::OperatorConverter.apply_summary(new_data_criteria, precondition, restriction, @data_criteria_converter)
+              else
+                case operator.type
+                when 'REFR'
+                  if operator.field.downcase == 'status'
+                    # only set the status if we don't have one.  We trust the template ID statuses more than the restrictions
+                    new_data_criteria.status ||= operator.value.code
+                  elsif operator.field.downcase == 'result value' or operator.field.downcase == 'result'
+                    puts "\tREFR result value is nil: #{new_data_criteria.title}" if (operator.value.nil?)
+                    new_data_criteria.value = operator.value
+                  else
+                    new_data_criteria.field_values ||= {}
+                    new_data_criteria.field_values[operator.field_value_key] = operator.value
+                  end
+                  restriction.converted=true
+                when 'RSON'
+                  new_data_criteria.negation_code_list_id = operator.value.code_list_id
+                  new_data_criteria.negation=true
+                  restriction.converted=true
+                when 'SUBJ'
+                  new_data_criteria.field_values ||= {}
+                  new_data_criteria.field_values[operator.field_value_key] = operator.value
+                  restriction.converted=true
+                else
+                  puts "\tOperator is unknown: #{operator.type}"
+                  restriction.converted=true
+                end
+              end
+            end
+            precondition.delete_converted_restrictions!
+            precondition.processed = true
+          end
+        end
+      end
+    end
+  
+    def has_child_comparison(node)
+      get_child_comparisons(node).length > 0
+    end
+
+    def rewrite_observation(observation)
+      first_comparison = get_child_comparisons(observation).first
+      # clear the conjunction code since this should be a comparison
+      first_comparison.conjunction_code = nil
+
+      # we want to pull the aggregation function off of the top level comparison
+      first_criteria = @data_criteria_converter.v2_data_criteria_by_id[first_comparison.reference.id]
+      # pop the last subset operator which should be the closest to the root of the logic tree.  Add that aggregation function to the observation as the aggregator
+      observation.aggregator = first_criteria.subset_operators.pop.type
+
+      # we want to get rid of any AND statements at the top level.  This is calculating a numeric value, not evaluating boolean logic
+      observation.preconditions.clear
+      observation.preconditions << first_comparison
+    end
+
+    def get_child_comparisons(node)
+      values = []
+      node.preconditions.each do |precondition|
+        if (precondition.comparison?)
+          values << precondition
+        elsif precondition.preconditions
+          values.concat get_child_comparisons(precondition)
+        end
+      end if node.preconditions
+      values
+    end
+
+  end  
+end