cqm-validators 0.1.1 → 1.0.1.0

data/lib/reported_result_extractor.rb

@@ -1,172 +1,170 @@
+# frozen_string_literal: true
+
 module CqmValidators
   module ReportedResultExtractor
+    # takes a document and a list of 1 or more id hashes, e.g.:
+    # [{measure_id:"8a4d92b2-36af-5758-0136-ea8c43244986", set_id:"03876d69-085b-415c-ae9d-9924171040c2", ipp:"D77106C4-8ED0-4C5D-B29E-13DBF255B9FF",
+    # den:"8B0FA80F-8FFE-494C-958A-191C1BB36DBF", num:"9363135E-A816-451F-8022-96CDA7E540DD"}]
+    # returns nil if nothing matching is found
+    # returns a hash with the values of the populations filled out along with the population_ids added to the result
 
-    #takes a document and a list of 1 or more id hashes, e.g.:
-      #[{measure_id:"8a4d92b2-36af-5758-0136-ea8c43244986", set_id:"03876d69-085b-415c-ae9d-9924171040c2", ipp:"D77106C4-8ED0-4C5D-B29E-13DBF255B9FF", den:"8B0FA80F-8FFE-494C-958A-191C1BB36DBF", num:"9363135E-A816-451F-8022-96CDA7E540DD"}]
-      #returns nil if nothing matching is found
-      # returns a hash with the values of the populations filled out along with the population_ids added to the result
-
-
-      def extract_results_by_ids(measure_id, ids, doc)
-        results = nil
-        _ids = ids.dup
-        stratification = _ids.delete("stratification")
-        stratification ||= _ids.delete("STRAT")
-        errors = []
-        nodes = find_measure_node(measure_id, doc)
+    ALL_POPULATION_CODES = %w[IPP DENOM NUMER NUMEX DENEX DENEXCEP MSRPOPL MSRPOPLEX OBSERV].freeze
 
-        if nodes.nil? || nodes.empty?
-          # short circuit and return nil
-          return {}
-        end
+    def extract_results_by_ids(measure, poulation_set_id, doc, stratification_id = nil)
+      results = nil
+      nodes = find_measure_node(measure.hqmf_id, doc)
 
-        nodes.each do |n|
-         results =  get_measure_components(n, _ids, stratification)
-         break if (results != nil || (results != nil && !results.empty?))
-        end
-        return nil if results.nil?
-        results[:population_ids] = ids.dup
-        results
+      if nodes.nil? || nodes.empty?
+        # short circuit and return nil
+        return {}
       end
 
-      def find_measure_node(id, doc)
-         xpath_measures = %Q{/cda:ClinicalDocument/cda:component/cda:structuredBody/cda:component/cda:section
-          /cda:entry/cda:organizer[ ./cda:templateId[@root = "2.16.840.1.113883.10.20.27.3.1"]
-          and ./cda:reference/cda:externalDocument/cda:id[#{translate("@extension")}='#{id.upcase}' and #{translate("@root")}='2.16.840.1.113883.4.738']]}
-         return doc.xpath(xpath_measures)
+      nodes.each do |n|
+        results = get_measure_components(n, measure.population_sets.where(population_set_id: poulation_set_id).first, stratification_id)
+        break if !results.nil? || (!results.nil? && !results.empty?)
       end
+      return nil if results.nil?
 
-      def get_measure_components(n,ids, stratification)
-        results = {:supplemental_data =>{}}
-        ids.each_pair do |k,v|
-          val = nil
-          sup = nil
-          if (k == 'OBSERV')
-            msrpopl = ids['MSRPOPL']
-            val, sup = extract_cv_value(n,v,msrpopl, stratification)
-          else
-            val,sup,pr =extract_component_value(n,k,v,stratification)
-          end
-          if !val.nil?
-            results[k.to_s] = val
-            results[:supplemental_data][k] = sup
-          else
-            # return nil
-          end
-          if !pr.nil?
-            results["PR"] = pr
-          end
-        end
-        results
-      end
+      results
+    end
 
-    def extract_cv_value(node, id, msrpopl, strata = nil)
-        xpath_observation = %{ cda:component/cda:observation[./cda:value[@code = "MSRPOPL"] and ./cda:reference/cda:externalObservation/cda:id[#{translate("@root")}='#{msrpopl.upcase}']]}
-        cv = node.at_xpath(xpath_observation)
-        return nil unless cv
-        val = nil
-        if strata
-        strata_path = %{ cda:entryRelationship[@typeCode="COMP"]/cda:observation[./cda:templateId[@root = "2.16.840.1.113883.10.20.27.3.4"]  and ./cda:reference/cda:externalObservation/cda:id[#{translate("@root")}='#{strata.upcase}']]}
-        n = cv.xpath(strata_path)
-        val = get_cv_value(n,id)
-        else
-        val = get_cv_value(cv,id)
-        end
-        return val, (strata.nil? ?  extract_supplemental_data(cv) : nil)
-      end
+    def find_measure_node(id, doc)
+      xpath_measures = %(/cda:ClinicalDocument/cda:component/cda:structuredBody/cda:component/cda:section
+       /cda:entry/cda:organizer[ ./cda:templateId[@root = "2.16.840.1.113883.10.20.27.3.1"]
+       and ./cda:reference/cda:externalDocument/cda:id[#{translate('@extension')}='#{id.upcase}' and #{translate('@root')}='2.16.840.1.113883.4.738']])
+      doc.xpath(xpath_measures)
+    end
+
+    def get_measure_components(n, population_set, stratification_id)
+      results = { supplemental_data: {} }
+      stratification = stratification_id ? population_set.stratifications.where(stratification_id: stratification_id).first.hqmf_id : nil
+      ALL_POPULATION_CODES.each do |pop_code|
+        next unless population_set.populations[pop_code] || pop_code == 'OBSERV'
 
-      def extract_component_value(node, code, id, strata = nil)
-        xpath_observation = %{ cda:component/cda:observation[./cda:value[@code = "#{code}"] and ./cda:reference/cda:externalObservation/cda:id[#{translate("@root")}='#{id.upcase}']]}
-        cv = node.at_xpath(xpath_observation)
-        return nil unless cv
         val = nil
-        if strata
-          strata_path = %{ cda:entryRelationship[@typeCode="COMP"]/cda:observation[./cda:templateId[@root = "2.16.840.1.113883.10.20.27.3.4"]  and ./cda:reference/cda:externalObservation/cda:id[#{translate("@root")}='#{strata.upcase}']]}
-          n = cv.xpath(strata_path)
-          val = get_aggregate_count(n) if n
+        sup = nil
+        if pop_code == 'OBSERV'
+          next unless population_set.populations['MSRPOPL']
+
+          msrpopl = population_set.populations['MSRPOPL']['hqmf_id']
+          val, sup = extract_cv_value(n, population_set.observations.first.hqmf_id, msrpopl, stratification)
         else
-          val = get_aggregate_count(cv)
+          val, sup, pr = extract_component_value(n, pop_code, population_set.populations[pop_code]['hqmf_id'], stratification)
         end
-        #Performance rate is only applicable for unstratified values
-        if code == "NUMER" && strata == nil
-          pref_rate_value = extract_performance_rate(node,code,id)
+        unless val.nil?
+          results[pop_code] = val
+          results[:supplemental_data][pop_code] = sup
         end
-        return val,(strata.nil? ?  extract_supplemental_data(cv) : nil),pref_rate_value
+        results['PR'] = pr unless pr.nil?
       end
+      results
+    end
 
-    def extract_performance_rate(node,code,id)
-        xpath_perf_rate = %{ cda:component/cda:observation[./cda:templateId[@root = "2.16.840.1.113883.10.20.27.3.14"] and ./cda:reference/cda:externalObservation/cda:id[#{translate("@root")}='#{id.upcase}']]/cda:value}
-        perf_rate = node.at_xpath(xpath_perf_rate)
-        pref_rate_value = {}
-        if perf_rate != nil
-          if perf_rate.at_xpath("./@nullFlavor")
-            pref_rate_value["nullFlavor"] = "NA"
-            return pref_rate_value
-          else
-            pref_rate_value["value"] = perf_rate.at_xpath("./@value").value
-            return pref_rate_value
-          end
-        end
-        return nil
+    def extract_cv_value(node, id, msrpopl, strata = nil)
+      xpath_observation = %( cda:component/cda:observation[./cda:value[@code = "MSRPOPL"] and ./cda:reference/cda:externalObservation/cda:id[#{translate('@root')}='#{msrpopl.upcase}']])
+      cv = node.at_xpath(xpath_observation)
+      return nil unless cv
+
+      val = nil
+      if strata
+        strata_path = %( cda:entryRelationship[@typeCode="COMP"]/cda:observation[./cda:templateId[@root = "2.16.840.1.113883.10.20.27.3.4"]  and ./cda:reference/cda:externalObservation/cda:id[#{translate('@root')}='#{strata.upcase}']])
+        n = cv.xpath(strata_path)
+        val = get_cv_value(n, id)
+      else
+        val = get_cv_value(cv, id)
       end
-          # convert numbers in value nodes to Int / Float as necessary TODO add more types other than 'REAL'
-      def convert_value(value_node)
-        if value_node.nil?
-          return
-        end
-        if value_node['type'] == 'REAL' || value_node['value'].include?('.')
-          return value_node['value'].to_f
+      [val, (strata.nil? ? extract_supplemental_data(cv) : nil)]
+    end
+
+    def extract_component_value(node, code, id, strata = nil)
+      code = 'IPOP' if code == 'IPP'
+      xpath_observation = %( cda:component/cda:observation[./cda:value[@code = "#{code}"] and ./cda:reference/cda:externalObservation/cda:id[#{translate('@root')}='#{id.upcase}']])
+      cv = node.at_xpath(xpath_observation)
+      return nil unless cv
+
+      val = nil
+      if strata
+        strata_path = %( cda:entryRelationship[@typeCode="COMP"]/cda:observation[./cda:templateId[@root = "2.16.840.1.113883.10.20.27.3.4"]  and ./cda:reference/cda:externalObservation/cda:id[#{translate('@root')}='#{strata.upcase}']])
+        n = cv.xpath(strata_path)
+        val = get_aggregate_count(n) if n
+      else
+        val = get_aggregate_count(cv)
+      end
+      # Performance rate is only applicable for unstratified values
+      pref_rate_value = extract_performance_rate(node, code, id) if code == 'NUMER' && strata.nil?
+      [val, (strata.nil? ? extract_supplemental_data(cv) : nil), pref_rate_value]
+    end
+
+    def extract_performance_rate(node, _code, id)
+      xpath_perf_rate = %( cda:component/cda:observation[./cda:templateId[@root = "2.16.840.1.113883.10.20.27.3.14"] and ./cda:reference/cda:externalObservation/cda:id[#{translate('@root')}='#{id.upcase}']]/cda:value)
+      perf_rate = node.at_xpath(xpath_perf_rate)
+      pref_rate_value = {}
+      unless perf_rate.nil?
+        if perf_rate.at_xpath('./@nullFlavor')
+          pref_rate_value['nullFlavor'] = 'NA'
         else
-          return value_node['value'].to_i
+          pref_rate_value['value'] = perf_rate.at_xpath('./@value').value
         end
+        return pref_rate_value
       end
+      nil
+    end
 
-      #given an observation node with an aggregate count node, return the reported and expected value within the count node
-      def get_cv_value(node, cv_id)
-        xpath_value = %{cda:entryRelationship/cda:observation[./cda:templateId[@root="2.16.840.1.113883.10.20.27.3.2"] and ./cda:reference/cda:externalObservation/cda:id[#{translate("@root")}='#{cv_id.upcase}']]/cda:value}
+    # convert numbers in value nodes to Int / Float as necessary
+    # TODO: add more types other than 'REAL'
+    def convert_value(value_node)
+      return if value_node.nil?
+      return value_node['value'].to_f if value_node['type'] == 'REAL' || value_node['value'].include?('.')
 
-        value_node = node.at_xpath(xpath_value)
-        value = convert_value(value_node) if value_node
-        value
-      end
+      value_node['value'].to_i
+    end
 
-      #given an observation node with an aggregate count node, return the reported and expected value within the count node
-      def get_aggregate_count(node)
-        xpath_value = 'cda:entryRelationship/cda:observation[./cda:templateId[@root="2.16.840.1.113883.10.20.27.3.3"]]/cda:value'
-        value_node = node.at_xpath(xpath_value)
-        value = convert_value(value_node) if value_node
-        value
-      end
+    # given an observation node with an aggregate count node, return the reported and expected value within the count node
+    def get_cv_value(node, cv_id)
+      xpath_value = %(cda:entryRelationship/cda:observation[./cda:templateId[@root="2.16.840.1.113883.10.20.27.3.2"] and ./cda:reference/cda:externalObservation/cda:id[#{translate('@root')}='#{cv_id.upcase}']]/cda:value)
+
+      value_node = node.at_xpath(xpath_value)
+      value = convert_value(value_node) if value_node
+      value
+    end
+
+    # given an observation node with an aggregate count node, return the reported and expected value within the count node
+    def get_aggregate_count(node)
+      xpath_value = 'cda:entryRelationship/cda:observation[./cda:templateId[@root="2.16.840.1.113883.10.20.27.3.3"]]/cda:value'
+      value_node = node.at_xpath(xpath_value)
+      value = convert_value(value_node) if value_node
+      value
+    end
 
-      def extract_supplemental_data(cv)
-        ret = {}
-        supplemental_data_mapping = {"RACE"=> "2.16.840.1.113883.10.20.27.3.8",
-                             "ETHNICITY" => "2.16.840.1.113883.10.20.27.3.7",
-                             "SEX" => "2.16.840.1.113883.10.20.27.3.6",
-                             "PAYER" => "2.16.840.1.113883.10.20.27.3.9"}
-        supplemental_data_mapping.each_pair do |supp, id|
-          key_hash = {}
-          xpath = "cda:entryRelationship/cda:observation[cda:templateId[@root='#{id}']]"
-          (cv.xpath(xpath) || []).each do |node|
-            value = node.at_xpath('cda:value')
-            count = get_aggregate_count(node)
-            if value.at_xpath("./@nullFlavor")
-             if supp == "PAYER" && value['xsi:type'] == 'CD' && value['nullFlavor'] == 'OTH' && value.at_xpath("cda:translation") && value.at_xpath("cda:translation")['code']
-              key_hash[value.at_xpath("cda:translation")['code']] = count
-             else
-              key_hash["UNK"] = count
-             end
+    def extract_supplemental_data(cv)
+      ret = {}
+      supplemental_data_mapping = { 'RACE' => '2.16.840.1.113883.10.20.27.3.8',
+                                    'ETHNICITY' => '2.16.840.1.113883.10.20.27.3.7',
+                                    'SEX' => '2.16.840.1.113883.10.20.27.3.6',
+                                    'PAYER' => '2.16.840.1.113883.10.20.27.3.9' }
+      supplemental_data_mapping.each_pair do |supp, id|
+        key_hash = {}
+        xpath = "cda:entryRelationship/cda:observation[cda:templateId[@root='#{id}']]"
+        (cv.xpath(xpath) || []).each do |node|
+          value = node.at_xpath('cda:value')
+          count = get_aggregate_count(node)
+          if value.at_xpath('./@nullFlavor')
+            if supp == 'PAYER' && value['xsi:type'] == 'CD' && value['nullFlavor'] == 'OTH' && value.at_xpath('cda:translation') && value.at_xpath('cda:translation')['code']
+              key_hash[value.at_xpath('cda:translation')['code']] = count
             else
-             key_hash[value['code']] = count
+              key_hash['UNK'] = count
             end
+          else
+            key_hash[value['code']] = count
           end
-          ret[supp.to_s] = key_hash
         end
-        ret
+        ret[supp.to_s] = key_hash
       end
+      ret
+    end
 
-      def translate(id)
-        %{translate(#{id}, "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ")}
-      end
+    def translate(id)
+      %{translate(#{id}, "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ")}
     end
+  end
 end

data/lib/schema_validator.rb

@@ -1,23 +1,24 @@
+# frozen_string_literal: true
+
 module CqmValidators
-      module Schema
-        class Validator
-          include BaseValidator
-  
-          def initialize(name, schema_file)
-            @name = name
-            @schema_file = schema_file
-            @xsd = Nokogiri::XML::Schema(File.new(@schema_file))
-          end
-  
-          # Validate the document against the configured schema
-          def validate(document,data={})
-            @xsd.errors.clear
-            doc = get_document(document)
-            @xsd.validate(doc).map do |error|
-              build_error(error.message, "/", data[:file_name])
-            end
-          end
+  module Schema
+    class Validator
+      include BaseValidator
+
+      def initialize(name, schema_file)
+        @name = name
+        @schema_file = schema_file
+        @xsd = Nokogiri::XML::Schema(File.new(@schema_file))
+      end
+
+      # Validate the document against the configured schema
+      def validate(document, data = {})
+        @xsd.errors.clear
+        doc = get_document(document)
+        @xsd.validate(doc).map do |error|
+          build_error(error.message, '/', data[:file_name])
         end
       end
+    end
+  end
 end
-  

data/lib/schematron/c_processor.rb

@@ -1,26 +1,26 @@
-module CqmValidators
-      module Schematron
-        module CProcessor
-
+# frozen_string_literal: true
 
-          def get_errors(document)
-            document = get_document(document)
-            processor.transform(document)
-          end
+module CqmValidators
+  module Schematron
+    module CProcessor
+      def get_errors(document)
+        document = get_document(document)
+        processor.transform(document)
+      end
 
-          def processor
-            return @processor if @processor
-            doc = Nokogiri::XML(File.open(@schematron_file))
-            doc.root["defaultPhase"] = ("errors")
+      def processor
+        return @processor if @processor
 
-            xslt = Nokogiri::XSLT(File.open(ISO_SCHEMATRON))
+        doc = Nokogiri::XML(File.open(@schematron_file))
+        doc.root['defaultPhase'] = 'errors'
 
-            result = xslt.transform(doc)
-            #this is stupid but needs to be done to assocaite the xslt file with a dirctory
-            result = Nokogiri::XML(result.to_s,@schematron_file)
-            @processor = Nokogiri::XSLT::Stylesheet.parse_stylesheet_doc(result)
-          end
+        xslt = Nokogiri::XSLT(File.open(ISO_SCHEMATRON))
 
-        end
+        result = xslt.transform(doc)
+        # this needs to be done to associate the xslt file with a dirctory
+        result = Nokogiri::XML(result.to_s, @schematron_file)
+        @processor = Nokogiri::XSLT::Stylesheet.parse_stylesheet_doc(result)
       end
+    end
+  end
 end

data/lib/schematron/java_processor.rb

@@ -1,92 +1,90 @@
+# frozen_string_literal: true
+
 require 'java'
 require_relative '../../../../java/saxon9he.jar'
 
-java_import "java.io.StringReader"
-java_import "java.io.StringWriter"
-
-java_import "javax.xml.parsers.DocumentBuilder"
-java_import "javax.xml.parsers.DocumentBuilderFactory"
+java_import 'java.io.StringReader'
+java_import 'java.io.StringWriter'
 
-java_import "javax.xml.transform.TransformerFactory"
-java_import "javax.xml.transform.Transformer"
-java_import "javax.xml.transform.dom.DOMSource"
-java_import "javax.xml.transform.stream.StreamSource"
-java_import "javax.xml.transform.stream.StreamResult"
+java_import 'javax.xml.parsers.DocumentBuilder'
+java_import 'javax.xml.parsers.DocumentBuilderFactory'
 
-java_import "org.w3c.dom.Document"
+java_import 'javax.xml.transform.TransformerFactory'
+java_import 'javax.xml.transform.Transformer'
+java_import 'javax.xml.transform.dom.DOMSource'
+java_import 'javax.xml.transform.stream.StreamSource'
+java_import 'javax.xml.transform.stream.StreamResult'
 
+java_import 'org.w3c.dom.Document'
 
-TRANSFORMER_FACTORY_IMPL = "net.sf.saxon.TransformerFactoryImpl"
+TRANSFORMER_FACTORY_IMPL = 'net.sf.saxon.TransformerFactoryImpl'
 
 module CqmValidators
-    module Schematron
-      module JavaProcessor
+  module Schematron
+    module JavaProcessor
+      ISO_SCHEMATRON2 = File.join(DIR, 'lib/schematron/iso-schematron-xslt2/iso_svrl_for_xslt2.xsl')
 
-        ISO_SCHEMATRON2 = File.join(DIR, 'lib/schematron/iso-schematron-xslt2/iso_svrl_for_xslt2.xsl')
+      class HdsUrlResolver
+        include javax.xml.transform.URIResolver
 
-        class HdsUrlResolver
-          include javax.xml.transform.URIResolver
+        def initialize(schematron)
+          @file = schematron
+        end
 
-          def initialize(schematron)
-            @file = schematron
-          end
+        def resolve(href, _base)
+          path = File.join(File.dirname(@file), href)
+          StreamSource.new(java.io.File.new(path))
+        end
+      end
 
-          def resolve(href, base)
-            path = File.join(File.dirname(@file), href)
-            return StreamSource.new(java.io.File.new(path))
-          end
+      def get_errors(document)
+        document_j = get_document_j(document)
+        output = build_transformer(StringReader.new(processor), StreamSource.new(document_j), true)
+        Nokogiri::XML(output)
+      end
 
+      def get_document_j(doc)
+        case doc
+        when File
+          java.io.File.new(doc.path)
+        else
+          StringReader.new(doc.to_s)
         end
+      end
 
-        def get_errors(document)
-          document_j = get_document_j(document)
-          output = build_transformer(StringReader.new(processor), StreamSource.new(document_j), true)
-          Nokogiri::XML(output)
-        end
+      def processor
+        @processor ||= build_transformer(java.io.File.new(ISO_SCHEMATRON2), schematron_file)
+      end
 
-        def get_document_j(doc)
-          case doc
-          when File
-            java.io.File.new(doc.path)
-          else
-            StringReader.new(doc.to_s)
-          end
+      def schematron_file
+        # this allows us to run the validation utility app in jBoss/TorqueBox
+        # for some reason it breaks the first time you call DocumentBuilderFactory,
+        # so the solution is to catch the error and retry
+        # TODO: pull this out when the above is no longer the case.
+        begin
+          dbf = DocumentBuilderFactory.new_instance
+        rescue Exception
+          retry
         end
+        dbf.setIgnoringElementContentWhitespace(true)
+        db = dbf.new_document_builder
+        document = db.parse(java.io.File.new(@schematron_file))
 
-        def processor
-          @processor ||= build_transformer(java.io.File.new(ISO_SCHEMATRON2), schematron_file)
-        end
+        root = document.document_element
+        root.set_attribute('defaultPhase', 'errors')
 
-        def schematron_file
-          byebug
-          # this allows us to run the validation utility app in jBoss/TorqueBox
-          # for some reason it breaks the first time you call DocumentBuilderFactory,
-          # so the solution is to catch the error and retry
-          # TODO: pull this out when the above is no longer the case.
-          begin
-            dbf = DocumentBuilderFactory.new_instance
-          rescue Exception => ex
-            retry
-          end
-          dbf.setIgnoringElementContentWhitespace(true);
-          db = dbf.new_document_builder
-          document = db.parse(java.io.File.new(@schematron_file))
-
-          root = document.document_element
-          phase = root.set_attribute("defaultPhase", "errors")
-
-          DOMSource.new(root)
-        end
+        DOMSource.new(root)
+      end
 
-        def build_transformer(xslt, input_file, url=false)
-          factory = TransformerFactory.newInstance(TRANSFORMER_FACTORY_IMPL, nil)
-          factory.uri_resolver = HdsUrlResolver.new(@schematron_file) if url
-          transformer = factory.new_transformer(StreamSource.new(xslt))
-          sw = StringWriter.new
-          output = StreamResult.new(sw)
-          transformer.transform(input_file, output)
-          sw.to_s
-        end
+      def build_transformer(xslt, input_file, url = false)
+        factory = TransformerFactory.newInstance(TRANSFORMER_FACTORY_IMPL, nil)
+        factory.uri_resolver = HdsUrlResolver.new(@schematron_file) if url
+        transformer = factory.new_transformer(StreamSource.new(xslt))
+        sw = StringWriter.new
+        output = StreamResult.new(sw)
+        transformer.transform(input_file, output)
+        sw.to_s
       end
     end
   end
+end