cqm-parsers 0.1.0

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 || HQMF::AnyValue.new
+                  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

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

@@ -0,0 +1,102 @@
+module HQMF
+  # Class for converting an HQMF 1.0 representation to an HQMF 2.0 representation
+  class OperatorConverter
+    
+    def self.apply_temporal(data_criteria, precondition, restriction, data_criteria_converter)
+      data_criteria.temporal_references ||= []
+      value = restriction.operator.value
+      type = restriction.operator.type
+      temporal_reference = nil
+      if (restriction.single_target?)
+        # multiple targets appears to be the result of restrictions with restrictions
+        target = restriction.target
+        if (restriction.multi_target?)
+          found = false
+          # restrictions with restrictions can have a target that is modified by the child restrcitons
+          restriction.preconditions.each do |precondition|
+            if precondition.reference.id.start_with? target
+              found = true
+              target = precondition.reference.id
+            end
+          end
+          unless found
+            puts "\tmultiple targets... need to check this" if restriction.multi_target?
+          end
+        end
+        temporal_reference = HQMF::TemporalReference.new(type, HQMF::Reference.new(target),value)
+        data_criteria_converter.validate_not_deleted(target)
+      elsif (restriction.multi_target?)
+        
+        children_criteria = HQMF::DataCriteriaConverter.extract_data_criteria(restriction.preconditions, data_criteria_converter)
+        
+        if (children_criteria.length == 1)
+          target = children_criteria[0].id
+          temporal_reference = HQMF::TemporalReference.new(type, HQMF::Reference.new(target),value)
+          data_criteria_converter.validate_not_deleted(target)
+        else
+          parent_id = "GROUP"
+          if restriction.generated_data_criteria.nil?
+            # we pass in restriction.preconditions here rather than children_criteria because we need to be able to create grouping data criteria for and and or preconditions in a tree
+            group_criteria = data_criteria_converter.create_group_data_criteria(restriction.preconditions, "#{type}_CHILDREN", value, parent_id, HQMF::Counter.instance.next, "grouping", "temporal")
+            # save the generated grouping criteria so that we can reference it from other locations
+            restriction.generated_data_criteria = group_criteria
+          else
+            # we have already processed this restriction and have a grouping criteria for it.  Take the one we have previously generated
+            group_criteria = restriction.generated_data_criteria
+          end
+          temporal_reference = HQMF::TemporalReference.new(type, HQMF::Reference.new(group_criteria.id), value)
+        end
+      else
+        raise "no target for temporal restriction"
+      end
+      restriction.converted=true
+      
+      # add temporal reference to data criteria
+      data_criteria.temporal_references << temporal_reference unless data_criteria.has_temporal(temporal_reference)
+    end
+    
+    
+    def self.apply_summary(data_criteria, precondition, restriction, data_criteria_converter)
+      value = restriction.operator.value
+      type = restriction.operator.type
+      subset_operator = HQMF::SubsetOperator.new(type, value)
+
+      if (restriction.multi_target?)
+        children_criteria = HQMF::DataCriteriaConverter.extract_data_criteria(restriction.preconditions, data_criteria_converter)
+        
+        data_criteria = nil
+        if (children_criteria.length == 1)
+          data_criteria = children_criteria[0]
+          data_criteria.subset_operators ||= []
+          # add subset operator to data criteria
+          data_criteria.subset_operators << subset_operator unless data_criteria.has_subset(subset_operator)
+        else
+          parent_id = "GROUP"
+          
+          if restriction.generated_data_criteria.nil?
+            # we pass in restriction.preconditions here rather than children_criteria because we need to be able to create grouping data criteria for and and or preconditions in a tree
+            data_criteria = data_criteria_converter.create_group_data_criteria(restriction.preconditions, type, value, parent_id, HQMF::Counter.instance.next, "grouping", "summary")
+            # save the generated grouping criteria so that we can reference it from other locations
+            restriction.generated_data_criteria = data_criteria
+          else
+            # we have already processed this restriction and have a grouping criteria for it.  Take the one we have previously generated
+            data_criteria = restriction.generated_data_criteria
+          end
+          
+          data_criteria.subset_operators ||= []
+          # add subset operator to data criteria
+          data_criteria.subset_operators << subset_operator unless data_criteria.has_subset(subset_operator)
+        end
+        precondition.reference = HQMF::Reference.new(data_criteria.id)
+      elsif (restriction.single_target?)
+        subset_operator = HQMF::SubsetOperator.new(type, value)
+        data_criteria.subset_operators ||= []
+        # add subset operator to data criteria
+        data_criteria.subset_operators << subset_operator unless data_criteria.has_subset(subset_operator)
+      end
+      
+      restriction.converted=true
+    end
+    
+  end  
+end