hqmf-parser 1.0.0

data/lib/hqmf-parser/1.0/expression.rb

@@ -0,0 +1,52 @@
+module HQMF1
+  
+  class Expression
+  
+    include HQMF1::Utilities
+    
+    attr_reader :text, :value, :type
+  
+    def initialize(entry)
+      @entry = entry
+      @text = @entry.xpath('./*/cda:derivationExpr').text.strip
+      type = attr_val('./*/cda:value/@xsi:type')
+      case type
+      when 'IVL_PQ'
+        @value = Range.new(@entry.xpath('./*/cda:value'))
+      when 'PQ'
+        @value = Value.new(@entry.xpath('./*/cda:value'))
+      when 'ANYNonNull'
+        @value = HQMF::AnyValue.new
+      else
+        raise "Unknown expression value type #{type}"
+      end
+      @type = match_type
+    end
+    
+    def match_type
+      case @text
+        when /^COUNT(.*)$/
+          "COUNT"
+        when /^MIN(.*)$/
+          "MIN"
+        when /^MAX(.*)$/
+          "MAX"
+        when /^DATEDIFF(.*)$/
+          "DATEDIFF"
+        else
+          raise "unknown expression type: #{@text}"
+      end
+    end
+    
+    def to_json
+      
+      json = build_hash(self, [:text,:type])
+      json[:value] = self.value.to_json if self.value
+      json
+      
+    end
+    
+  end
+  
+  
+end

data/lib/hqmf-parser/1.0/population_criteria.rb

@@ -0,0 +1,79 @@
+module HQMF1
+  # Represents an HQMF population criteria
+  class PopulationCriteria
+  
+    include HQMF1::Utilities
+    
+    attr_reader :preconditions, :entry, :doc
+    attr_accessor :id, :hqmf_id, :stratification_id
+    
+    # Create a new population criteria from the supplied HQMF entry
+    # @param [Nokogiri::XML::Element] the HQMF entry
+    def initialize(entry, doc)
+      @doc = doc
+      @entry = entry
+      @id = attr_val('cda:observation/cda:id/@root').upcase
+      @preconditions = @entry.xpath('./*/cda:sourceOf[@typeCode="PRCN"]').collect do |entry|
+        pc = Precondition.new(entry, nil, @doc)
+        if pc.preconditions.length==0 && !pc.comparison && pc.restrictions.length==0
+          nil
+        else
+          pc
+        end
+      end.compact
+    end
+    
+    # Get the code for the population criteria
+    # @return [String] the code (e.g. IPP, DEMON, NUMER, DENEX, EXCEP)
+    def code
+      value = attr_val('cda:observation/cda:value/@code')
+      # exclusion population criteria has id of DENOM with actionNegationInd of true
+      # special case this to simply handling
+      if attr_val('cda:observation/@actionNegationInd')=='true'
+        value = HQMF::PopulationCriteria::DENEX
+      end
+      # replace measure population with NUMER.  MSRPOPL is used in continuous variable calculations.
+      value = HQMF::PopulationCriteria::NUMER if value == 'MSRPOPL'
+      # replace DENEXCEP with EXCEP.  DENEXCEP is used by the MAT instead of EXCEP as required by HQMF V2 and QRDA.
+      value = HQMF::PopulationCriteria::EXCEP if value == 'DENEXCEP'
+      value.upcase
+    end
+    
+    # Get the id for the population criteria, used elsewhere in the HQMF document to
+    # refer to this criteria
+    # @return [String] the id
+    def id
+      @id
+    end
+    
+    def title
+      attr_val('cda:observation/cda:value/@displayName')
+    end
+    
+    def reference
+      reference = attr_val('./cda:observation/cda:sourceOf[@typeCode="PRCN"]/cda:observation[@classCode="OBS"]/cda:id/@root')
+      reference = reference.upcase if reference
+      reference
+    end
+    
+    def to_json
+      
+      json = {}
+      self.preconditions.compact.each do |precondition| 
+        json[:preconditions] ||= []
+        json[:preconditions] << precondition.to_json
+      end
+      
+      json[:id] = id
+      json[:title] = title
+      json[:code] = code
+      json[:hqmf_id] = hqmf_id if hqmf_id
+      json[:stratification_id] = stratification_id if stratification_id
+      json[:reference] = reference
+      
+      {self.code => json}
+      
+    end
+    
+  end
+end

data/lib/hqmf-parser/1.0/precondition.rb

@@ -0,0 +1,89 @@
+module HQMF1
+  
+  class Precondition
+  
+    include HQMF1::Utilities
+    
+    attr_reader :restrictions, :preconditions, :subset, :expression, :id
+  
+    def initialize(entry, parent, doc)
+      @doc = doc
+      @entry = entry
+      @id = attr_val('./*/cda:id/@root')
+      @restrictions = []
+      
+      local_subset = attr_val('./cda:subsetCode/@code')
+      if local_subset
+        @subset = local_subset
+      end
+      #@subset = attr_val('./cda:subsetCode/@code')
+      
+      local_restrictions = @entry.xpath('./*/cda:sourceOf[@typeCode!="PRCN" and @typeCode!="COMP"]').collect do |entry|
+        Restriction.new(entry, self, @doc)
+      end
+      @restrictions.concat(local_restrictions)
+
+      @expression = Expression.new(@entry) if @entry.at_xpath('./*/cda:derivationExpr')
+
+      @preconditions = @entry.xpath('./*/cda:sourceOf[@typeCode="PRCN"]').collect do |entry|
+        Precondition.new(entry, self, @doc)
+      end
+    end
+    
+    # Get the conjunction code, e.g. AND, OR
+    # @return [String] conjunction code
+    def conjunction
+      attr_val('./cda:conjunctionCode/@code')
+    end
+    
+    # Return whether the precondition is negated (true) or not (false)
+    def negation
+      if @entry.at_xpath('./cda:act[@actionNegationInd="true"]')
+        is_negation_rationale = (comparison.restrictions.map {|restriction| restriction.type }).include? 'RSON' if comparison
+        if is_negation_rationale
+          false
+        else
+          true
+        end
+      else
+        false
+      end
+    end
+    
+    def comparison
+      comparison_def = @entry.at_xpath('./*/cda:sourceOf[@typeCode="COMP"]')
+      if comparison_def
+        data_criteria_id = attr_val('./*/cda:id/@root')
+        @comparison = Comparison.new(data_criteria_id, comparison_def, self, @doc)
+      end
+    end
+    
+    def first_comparison
+      if comparison
+        return comparison
+      elsif @preconditions
+        @preconditions.each do |precondition|
+          first = precondition.first_comparison
+          if first
+            return first
+          end
+        end
+      end
+      return nil
+    end
+    
+    def to_json
+      
+      json = build_hash(self, [:id,:conjunction,:negation,:subset])
+      json[:comparison] = self.comparison.to_json if self.comparison
+      json[:expression] = self.expression.to_json if self.expression
+      json[:preconditions] = json_array(self.preconditions)
+      json[:restrictions] = json_array(self.restrictions)
+      json
+      
+    end
+    
+  end
+  
+  
+end

data/lib/hqmf-parser/1.0/range.rb

@@ -0,0 +1,65 @@
+module HQMF1
+  # Represents a bound within a HQMF pauseQuantity, has a value, a unit and an
+  # inclusive/exclusive indicator
+  class Value
+    include HQMF1::Utilities
+    
+    def initialize(entry)
+      @entry = entry
+    end
+    
+    def value
+      attr_val('./@value')
+    end
+    
+    def unit
+      attr_val('./@unit')
+    end
+    
+    def inclusive?
+      case attr_val('./@inclusive')
+      when 'true'
+        true
+      else
+        false
+      end
+    end
+    
+    def to_json
+      build_hash(self, [:value,:unit,:inclusive?])
+    end
+  end
+  
+  # Represents a HQMF pauseQuantity which can have low and high bounds
+  class Range
+    include HQMF1::Utilities
+    attr_reader :low, :high
+    
+    def initialize(entry)
+      @entry = entry
+      if @entry
+        @low = optional_value('./cda:low')
+        @high = optional_value('./cda:high')
+      end
+    end
+   
+    def to_json
+      json = {}
+      json[:low] = self.low.to_json if self.low
+      json[:high] = self.high.to_json if self.high
+      json
+    end
+    
+    private
+    
+    def optional_value(xpath)
+      value_def = @entry.at_xpath(xpath)
+      if value_def
+        Value.new(value_def)
+      else
+        nil
+      end
+    end
+    
+  end
+end

data/lib/hqmf-parser/1.0/restriction.rb

@@ -0,0 +1,157 @@
+module HQMF1
+  # Represents a restriction on the allowable values of a data item
+  class Restriction
+  
+    include HQMF1::Utilities
+    
+    attr_reader :range, :comparison, :restrictions, :subset, :preconditions
+    attr_accessor :from_parent
+    
+    def initialize(entry, parent, doc)
+      @doc = doc
+      @entry = entry
+      @restrictions = []
+      
+      range_def = @entry.at_xpath('./cda:pauseQuantity')
+      if range_def
+        @range = Range.new(range_def)
+      end
+      
+      local_restrictions = @entry.xpath('./*/cda:sourceOf[@typeCode!="PRCN" and @typeCode!="COMP"]').collect do |entry|
+        Restriction.new(entry, self, @doc)
+      end
+      
+      @restrictions.concat(local_restrictions)
+      
+      local_subset = attr_val('./cda:subsetCode/@code')
+      if local_subset
+        @subset = local_subset
+      end
+      
+      #@subset = attr_val('./cda:subsetCode/@code')
+      
+      comparison_def = @entry.at_xpath('./*/cda:sourceOf[@typeCode="COMP"]')
+      if comparison_def
+        data_criteria_id = attr_val('./*/cda:id/@root')
+        data_criteria_id = comparison_def.at_xpath('./*/cda:id/@root').value if (data_criteria_id.nil? and comparison_def.at_xpath('./*/cda:id/@root'))
+        @comparison = Comparison.new(data_criteria_id, comparison_def, self, @doc)
+      end
+      
+      @preconditions = @entry.xpath('./*/cda:sourceOf[@typeCode="PRCN"]').collect do |entry|
+        # create a dummy parent with a single restriction copied from self minus the
+        # nested preconditions to avoid an infinite loop
+        prior_comparison = nil
+        if parent.class==HQMF1::Precondition
+          prior_comparison = parent.first_comparison
+        else
+          prior_comparison = @comparsion
+        end
+        current_restriction = OpenStruct.new(
+          'range' => @range,
+          'comparison' => prior_comparison,
+          'restrictions' => [],
+          'preconditions' => [],
+          'subset' => @subset,
+          'type' => type,
+          'target_id' => target_id,
+          'field' => field,
+          'field_code' => field_code,
+          'field_time' => field_time,
+          'value' => value)
+        all_restrictions = []
+        all_restrictions.concat @restrictions
+        all_restrictions << current_restriction
+        parent = OpenStruct.new(
+          'restrictions' => all_restrictions,
+          'subset' => @subset
+        )
+        p = Precondition.new(entry, parent, @doc)
+        
+      end
+      
+    end
+    
+    # The type of restriction, e.g. SBS, SBE etc
+    def type
+      attr_val('./@typeCode')
+    end
+
+    # is this type negated? true or false
+    def negation
+      attr_val('./@inversionInd') == "true"
+    end
+    
+    # The id of the data criteria or measurement property that the value
+    # will be compared against
+    def target_id
+      attr_val('./*/cda:id/@root')
+    end
+    
+    def field
+      attr_val('./cda:observation/cda:code/@displayName')
+    end
+
+    def field_code
+      attr_val('./cda:observation/cda:code/@code') || attr_val('./cda:encounter/cda:participant/cda:roleParticipant/@classCode')
+    end
+    
+    def field_time
+      effectiveTime = @entry.at_xpath('./cda:observation/cda:effectiveTime') || @entry.at_xpath('./cda:encounter/cda:participant/cda:roleParticipant/cda:effectiveTime')
+      
+      time = nil
+      if effectiveTime
+        time = :start if effectiveTime.at_xpath('./cda:low')
+        time = :end if effectiveTime.at_xpath('./cda:high')
+      end
+      time
+    end
+
+    
+    def value
+      value = nil
+      type = attr_val('./cda:observation/cda:value/@xsi:type') || 'CD'
+      case type
+      when 'IVL_PQ'
+        value = HQMF1::Range.new(@entry.xpath('./cda:observation/cda:value'))
+      when 'PQ'
+        value = HQMF1::Value.new(@entry.xpath('./cda:observation/cda:value'))
+      when 'CD'
+        if field && field.downcase == 'status'
+          code = attr_val('./cda:observation/cda:value/@displayName').downcase
+          value = HQMF::Coded.for_single_code('status',code,code)
+        elsif attr_val('./cda:observation/cda:value/@code')
+          oid = attr_val('./cda:observation/cda:value/@code')
+          title = attr_val('./cda:observation/cda:value/@displayName')
+          value = HQMF::Coded.for_code_list(oid,title)
+        elsif attr_val('./cda:encounter/cda:participant/cda:roleParticipant/cda:code/@code')
+          oid = attr_val('./cda:encounter/cda:participant/cda:roleParticipant/cda:code/@code')
+          title = attr_val('./cda:encounter/cda:participant/cda:roleParticipant/cda:code/@displayName')
+          value = HQMF::Coded.for_code_list(oid,title)
+        end
+      when 'ANYNonNull'
+        value = HQMF::AnyValue.new
+      else
+        raise "Unknown restriction value type #{type}"
+      end if type
+      value
+    end
+    
+    def to_json 
+      return nil if from_parent
+      json = build_hash(self, [:subset,:type,:target_id,:field,:field_code,:from_parent, :negation, :field_time])
+      json[:range] = range.to_json if range
+      if value
+        if value.is_a? String
+          json[:value] = value
+        else
+          json[:value] = value.to_json
+        end
+      end
+      json[:comparison] = comparison.to_json if comparison
+      json[:restrictions] = json_array(self.restrictions)
+      json[:preconditions] = json_array(self.preconditions)
+      json
+    end
+
+  end
+end

data/lib/hqmf-parser/1.0/utilities.rb

@@ -0,0 +1,41 @@
+module HQMF1
+  module Utilities
+    
+    include HQMF::Conversion::Utilities
+    
+    # Utility function to handle optional attributes
+    # @param xpath an XPath that identifies an XML attribute
+    # @return the value of the attribute or nil if the attribute is missing
+    def attr_val(xpath)
+      attr = @entry.at_xpath(xpath)
+      if attr
+        attr.value
+      else
+        nil
+      end
+    end
+    
+    def clean_json(json)
+      json.reject!{|k,v| v.nil? || (v.respond_to?(:empty?) && v.empty?)}
+    end
+    
+    def clean_json_recursive(json)
+      json.each do |k,v|
+        if v.is_a? Hash
+          clean_json_recursive(v)
+          clean_json(v)
+        elsif v.is_a? Array
+          v.each do |e|
+            if e.is_a? Hash
+              clean_json_recursive(e)
+              clean_json(e)
+            end
+          end
+        end
+        
+      end
+      clean_json(json)
+    end
+    
+  end
+end