cqm-parsers 0.2.2 → 3.0.0.0

data/lib/measure-loader/elm_parser.rb

@@ -0,0 +1,67 @@
+module Measures
+  class ElmParser
+    # Fields are combined with the refId to find elm node that corrosponds to the current annotation node.
+    @fields = ['expression', 'operand', 'suchThat']
+
+    def self.parse(doc)
+      localid_to_type_map = generate_localid_to_type_map(doc)
+      ret = {
+        statements: [],
+        identifier: {}
+      }
+      # extract library identifier data
+      ret[:identifier][:id] = doc.css("identifier").attr("id").value
+      ret[:identifier][:version] = doc.css("identifier").attr("version").value
+
+      # extracts the fields of type "annotation" and their children.
+      annotations = doc.css("annotation")
+      annotations.each do |node|
+        node, define_name = parse_node(node, localid_to_type_map)
+        unless define_name.nil?
+          node[:define_name] = define_name
+          ret[:statements] << node
+        end
+      end
+      ret
+    end
+
+    # Recursive function that traverses the annotation tree and constructs a representation
+    # that will be compatible with the front end.
+    def self.parse_node(node, localid_to_type_map)
+      ret = {
+        children: []
+      }
+      define_name = nil
+      node.children.each do |child|
+        if child.is_a?(Nokogiri::XML::Text) # leaf node
+          clause_text = child.content.gsub(/\t/, "  ")
+          clause = {
+            text: clause_text
+          }
+          clause[:ref_id] = child['r'] unless child['r'].nil?
+          ret[:children] << clause
+          define_name = clause_text.split("\"")[1] if clause_text.strip.starts_with?("define")
+        else
+          node_type = localid_to_type_map[child['r']] unless child['r'].nil?
+          # Parses the current child recursively. child_define_name will bubble up to indicate which
+          # statement is currently being traversed.
+          node, child_define_name = parse_node(child, localid_to_type_map)
+          node[:node_type] = node_type  unless node_type.nil?
+          node[:ref_id] = child['r'] unless child['r'].nil?
+          ret[:children] << node
+          define_name = child_define_name unless child_define_name.nil?
+        end
+      end
+      return ret, define_name
+    end
+
+    def self.generate_localid_to_type_map(doc)
+      localid_to_type_map = {}
+      @fields.each do |field|
+        nodes = doc.css(field + '[localId][xsi|type]')
+        nodes.each {|node| localid_to_type_map[node['localId']] = node['xsi:type']}
+      end
+      return localid_to_type_map
+    end
+  end
+end

data/lib/measure-loader/exceptions.rb

@@ -0,0 +1,10 @@
+module Measures
+  class ValueSetException < StandardError
+  end
+  class HQMFException < StandardError
+  end
+  class MeasureLoadingInvalidPackageException < StandardError
+  end
+  class MeasureLoadingException < StandardError
+  end
+end 

data/lib/measure-loader/helpers.rb

@@ -0,0 +1,11 @@
+module Measures
+  module Helpers
+    def self.elm_id(elm)
+      return elm['library']['identifier']['id']
+    end
+
+    def self.elm_version(elm)
+      return elm['library']['identifier']['version']
+    end
+  end
+end

data/lib/measure-loader/hqmf_measure_loader.rb

@@ -0,0 +1,170 @@
+require 'cqm/models'
+
+module Measures
+  module HQMFMeasureLoader
+    class << self
+
+      def extract_fields(hqmf_xml)
+        qmd = hqmf_xml.at_css('/QualityMeasureDocument')
+        hqmf_id = qmd.at_css('/id')['root'].upcase
+        hqmf_set_id = qmd.at_css('/setId')['root'].upcase
+        title = qmd.at_css('/title')['value']
+        description = qmd.at_css('/text')['value']
+        cms_identifier = extract_cms_identifier(qmd)
+        hqmf_version_number = qmd.at_css('/versionNumber')['value']
+        cms_id = "CMS#{cms_identifier}v#{hqmf_version_number.to_i}"
+        main_cql_library = qmd.at_css('/component/populationCriteriaSection/component/initialPopulationCriteria/*/*/id')['extension'].split('.').first
+        measure_scoring = extract_measure_scoring(qmd)
+        population_sets = extract_population_set_models(qmd, measure_scoring)
+
+        return {
+          hqmf_id: hqmf_id,
+          hqmf_set_id: hqmf_set_id,
+          title: title,
+          description: description,
+          main_cql_library: main_cql_library,
+          hqmf_version_number: hqmf_version_number,
+          cms_id: cms_id,
+          measure_scoring: measure_scoring,
+          population_sets: population_sets
+        }
+      end
+
+      def add_fields_from_hqmf_model_hash(measure, hqmf_model_hash)
+        measure.measure_attributes = hqmf_model_hash[:attributes]
+        measure.measure_period = hqmf_model_hash[:measure_period]
+        measure.population_criteria = hqmf_model_hash[:population_criteria]
+
+        # add observation info, note population_sets needs to have been added to the measure by now
+        (hqmf_model_hash[:observations] || []).each do |observation|
+          observation = CQM::Observation.new(
+            hqmf_id: observation[:function_hqmf_oid],
+            aggregation_type: observation[:function_aggregation_type],
+            observation_function: CQM::StatementReference.new(
+              library_name: hqmf_model_hash[:cql_measure_library],
+              statement_name: observation[:function_name],
+              hqmf_id: observation[:function_hqmf_oid]
+            ),
+            observation_parameter: CQM::StatementReference.new(
+              library_name: hqmf_model_hash[:cql_measure_library],
+              statement_name: observation[:parameter],
+              hqmf_id: observation[:function_hqmf_oid]
+            )
+          )
+          # add observation to each population set
+          measure.population_sets.each { |population_set| population_set.observations << observation }
+        end
+      end
+
+      private
+
+      def extract_cms_identifier(qmd)
+        cms_identifier =
+          (qmd.at_xpath('./xmlns:subjectOf/xmlns:measureAttribute[xmlns:code/xmlns:originalText[@value="eCQM Identifier (Measure Authoring Tool)"]]/xmlns:value') ||
+          qmd.at_xpath('./xmlns:subjectOf/xmlns:measureAttribute[xmlns:code/xmlns:originalText[@value="eMeasure Identifier (Measure Authoring Tool)"]]/xmlns:value'))
+        return cms_identifier['value']
+      end
+
+      def extract_measure_scoring(qmd)
+        map_from_hqmf_name_to_full_name = {
+          'PROPOR' => 'PROPORTION',
+          'RATIO' => 'RATIO',
+          'CONTVAR' => 'CONTINUOUS_VARIABLE',
+          'COHORT' => 'COHORT'
+        }
+        scoring = qmd.at_xpath("./xmlns:subjectOf/xmlns:measureAttribute[xmlns:code/@code='MSRSCORE']/xmlns:value").attr('code')
+        scoring_full_name = map_from_hqmf_name_to_full_name[scoring]
+        raise StandardError.new("Unknown measure scoring type encountered #{scoring}") if scoring_full_name.nil?
+        return scoring_full_name
+      end
+
+      def extract_population_set_models(qmd, measure_scoring)
+        populations = qmd.css('/component/populationCriteriaSection')
+        return populations.map.with_index do |population, pop_index|
+          ps_hash = extract_population_set(population)
+          population_set = CQM::PopulationSet.new(
+            title: ps_hash[:title],
+            population_set_id: "PopulationSet_#{pop_index+1}"
+          )
+
+          population_set.populations = construct_population_map(measure_scoring)
+          ps_hash[:populations].each do |pop_code,statement_ref_hash|
+            population_set.populations[pop_code] = CQM::StatementReference.new(statement_ref_hash)
+          end
+
+          ps_hash[:supplemental_data_elements].each do |statement_ref_hash|
+            population_set.supplemental_data_elements << CQM::StatementReference.new(statement_ref_hash)
+          end
+
+          ps_hash[:stratifications].each_with_index do |statement_ref_hash, index|
+            population_set.stratifications << CQM::Stratification.new(
+              hqmf_id: statement_ref_hash[:hqmf_id],
+              stratification_id: "#{population_set.population_set_id}_Stratification_#{index+1}",
+              title: "PopSet#{pop_index+1} Stratification #{index+1}",
+              statement: CQM::StatementReference.new(statement_ref_hash)
+            )
+          end
+          population_set
+        end
+      end
+
+      def extract_population_set(population_hqmf_node)
+        ps = { populations: {}, stratifications: [], supplemental_data_elements: [] }
+        ps[:id] = population_hqmf_node.at_css('id').attr('extension')
+        ps[:title] = population_hqmf_node.at_css('title').attr('value')
+        criteria_components = population_hqmf_node.css('component').flat_map(&:children)
+        criteria_components.each do |cc|
+          statement_ref = cc.at_css('precondition/criteriaReference/id')
+          next if statement_ref.nil?
+          statement_ref_hash = { library_name: statement_ref.attr('extension').split('.')[0],
+                                 statement_name: Utilities.remove_enclosing_quotes(statement_ref.attr('extension').split('.')[1]),
+                                 hqmf_id: cc.at_css('id').attr('root') }
+          case cc.name
+          when 'initialPopulationCriteria'
+            ps[:populations][HQMF::PopulationCriteria::IPP] = statement_ref_hash
+          when 'denominatorCriteria'
+            ps[:populations][HQMF::PopulationCriteria::DENOM] = statement_ref_hash
+          when 'numeratorCriteria'
+            ps[:populations][HQMF::PopulationCriteria::NUMER] = statement_ref_hash
+          when 'numeratorExclusionCriteria'
+            ps[:populations][HQMF::PopulationCriteria::NUMEX] = statement_ref_hash
+          when 'denominatorExclusionCriteria'
+            ps[:populations][HQMF::PopulationCriteria::DENEX] = statement_ref_hash
+          when 'denominatorExceptionCriteria'
+            ps[:populations][HQMF::PopulationCriteria::DENEXCEP] = statement_ref_hash
+          when 'measurePopulationCriteria'
+            ps[:populations][HQMF::PopulationCriteria::MSRPOPL] = statement_ref_hash
+          when 'measurePopulationExclusionCriteria'
+            ps[:populations][HQMF::PopulationCriteria::MSRPOPLEX] = statement_ref_hash
+          when 'stratifierCriteria'
+            # Ignore Supplemental Data Elements
+            next if holds_supplemental_data_elements(cc)
+            ps[:stratifications] << statement_ref_hash
+          when 'supplementalDataElement'
+            ps[:supplemental_data_elements] << statement_ref_hash
+          end
+        end
+        return ps
+      end
+
+      def holds_supplemental_data_elements(criteria_component_node)
+        return criteria_component_node.at_css('component[@typeCode="COMP"]/measureAttribute/code[@code="SDE"]').present?
+      end
+
+      def construct_population_map(measure_scoring)
+        case measure_scoring
+        when 'PROPORTION'
+          CQM::ProportionPopulationMap.new
+        when 'RATIO'
+          CQM::RatioPopulationMap.new
+        when 'CONTINUOUS_VARIABLE'
+          CQM::ContinuousVariablePopulationMap.new
+        when 'COHORT'
+          CQM::CohortPopulationMap.new
+        else
+          raise StandardError.new("Unknown measure scoring type encountered #{measure_scoring}")
+        end
+      end
+    end
+  end
+end

data/lib/measure-loader/mat_measure_files.rb

@@ -0,0 +1,138 @@
+require 'zip'
+
+module Measures
+  class MATMeasureFiles
+    attr_accessor :hqmf_xml, :cql_libraries, :human_readable, :components
+
+    class CqlLibraryFiles
+      attr_accessor :id, :version, :cql, :elm, :elm_xml
+      def initialize(id, version, cql, elm, elm_xml)
+        @id = id
+        @version = version
+        @cql = cql
+        @elm = elm
+        @elm_xml = elm_xml
+      end
+    end
+
+    def initialize(hqmf_xml, cql_libraries, human_readable)
+      @hqmf_xml = hqmf_xml
+      @cql_libraries = cql_libraries
+      @human_readable = human_readable
+
+      raise MeasureLoadingInvalidPackageException.new("Measure package missing required element: HQMF XML File") if @hqmf_xml.nil?
+      raise MeasureLoadingInvalidPackageException.new("Measure package missing required element: Human Readable Document") if @human_readable.nil?
+      raise MeasureLoadingInvalidPackageException.new("Measure package missing required element: CQL Libraries") if @cql_libraries.nil? || @cql_libraries.empty?
+    end
+
+    def self.create_from_zip_file(zip_file)
+      folders = unzip_measure_zip_into_hash(zip_file).values
+      raise MeasureLoadingInvalidPackageException.new("No measure found") if folders.empty?
+      folders.sort_by! { |h| h[:depth] }
+      raise MeasureLoadingInvalidPackageException.new("Multiple measure folders at top level") if folders[0][:depth] == folders.dig(1,:depth)
+
+      measure_folder, *component_measure_folders = folders
+      measure_assets = make_measure_artifacts(parse_measure_files(measure_folder))
+      measure_assets.components = component_measure_folders.collect {|f| make_measure_artifacts(parse_measure_files(f))}
+
+      return measure_assets
+    rescue StandardError => e
+      raise MeasureLoadingInvalidPackageException.new("Error processing package file: #{e.message}")
+    end
+
+    def self.valid_zip?(zip_file)
+      create_from_zip_file(zip_file)
+      return true
+    rescue MeasureLoadingInvalidPackageException
+      return false
+    end
+
+    class << self
+
+      private
+
+      def unzip_measure_zip_into_hash(zip_file)
+        folders = Hash.new { |h, k| h[k] = {files: []} }
+        Zip::File.open zip_file.path do |file|
+          file.each do |f|
+            pn = Pathname(f.name)
+            next if '__MACOSX'.in? pn.each_filename  # ignore anything in a __MACOSX folder
+            next unless pn.basename.extname.in? ['.xml','.cql','.json','.html']
+            folders[pn.dirname][:files] << { basename: pn.basename, contents: f.get_input_stream.read }
+            folders[pn.dirname][:depth] =  pn.each_filename.count # this is just a count of how many folders are in the path
+          end
+        end
+        return folders
+      end
+
+      def make_measure_artifacts(measure_files)
+        library_count = measure_files[:cqls].length
+        unless (measure_files[:elm_xmls].length == library_count && measure_files[:elms].length == library_count)
+          raise MeasureLoadingInvalidPackageException.new("Each library must have a CQL file, an ELM JSON file, and an ELM XML file.")
+        end
+
+        cql_libraries = []
+        library_count.times do |i|
+          elm_annotation = measure_files[:elm_xmls][i]
+          elm = measure_files[:elms][i]
+          cql = measure_files[:cqls][i]
+
+          id, version = verify_library_versions_match_and_get_version(cql, elm, elm_annotation)
+          cql_libraries << CqlLibraryFiles.new(id, version, cql, elm, elm_annotation)
+        end
+
+        return new(measure_files[:hqmf_xml], cql_libraries, measure_files[:human_readable])
+      end
+
+      def parse_measure_files(folder)
+        measure_files = { cqls: [], elms: [], elm_xmls: [] }
+        folder[:files].sort_by! { |h| h[:basename] }
+        folder[:files].each do |file|
+          case file[:basename].extname.to_s
+          when '.cql'
+            measure_files[:cqls] << file[:contents]
+          when '.json'
+            begin
+              measure_files[:elms] << JSON.parse(file[:contents], max_nesting: 1000)
+            rescue StandardError
+              raise MeasureLoadingInvalidPackageException.new("Unable to parse json file #{basename}")
+            end
+          when '.html'
+            raise MeasureLoadingInvalidPackageException.new("Multiple HumanReadable docs found in same folder") unless measure_files[:human_readable].nil?
+            measure_files[:human_readable] = file[:contents]
+          when '.xml'
+            begin
+              doc = Nokogiri::XML(file[:contents]) { |config| config.noblanks }
+            rescue StandardError
+              raise MeasureLoadingInvalidPackageException.new("Unable to parse xml file #{basename}")
+            end
+            if doc.root.name == 'QualityMeasureDocument'
+              raise MeasureLoadingInvalidPackageException.new("Multiple QualityMeasureDocuments found in same folder") unless measure_files[:hqmf_xml].nil?
+              measure_files[:hqmf_xml] = doc
+            elsif doc.root.name == 'library'
+              measure_files[:elm_xmls] << doc
+            end
+          end
+        end
+        raise MeasureLoadingInvalidPackageException.new("Measure folder found with no hqmf") if measure_files[:hqmf_xml].nil?
+        return measure_files
+      end
+
+      def verify_library_versions_match_and_get_version(cql, elm, elm_annotation)
+        identifier = elm_annotation.at_xpath('/xmlns:library/xmlns:identifier')
+        id = identifier['id']
+        version = identifier['version']
+
+        if (Helpers.elm_id(elm)!= id ||
+            Helpers.elm_version(elm) != version ||
+            !(cql.include?("library #{id} version '#{version}'") || cql.include?("<library>#{id}</library><version>#{version}</version>"))
+           )
+          raise MeasureLoadingInvalidPackageException.new("Cql library assets must all have same version.")
+        end
+
+        return id, version
+      end
+
+    end
+  end
+end

data/lib/measure-loader/source_data_criteria_loader.rb

@@ -0,0 +1,75 @@
+module Measures
+  class SourceDataCriteriaLoader
+
+    def initialize(hqmf_xml, value_sets_from_single_code_references)
+      @hqmf_xml = hqmf_xml
+      @single_code_concepts = map_single_code_concepts(value_sets_from_single_code_references)
+    end
+
+    def extract_data_criteria
+      data_criteria_entries = @hqmf_xml.css('QualityMeasureDocument/component/dataCriteriaSection/entry')
+      source_data_criteria = data_criteria_entries.map { |entry| modelize_data_criteria_entry(entry) }
+
+      # We create the sdc in such a way that "negative" ones look positive in our array by now,
+      # so using uniq should give us an array of all positive criteria with no duplicates
+      source_data_criteria.uniq! { |sdc| "#{sdc.codeListId}_#{sdc.hqmfOid}" }
+      return source_data_criteria
+    end
+
+    private
+
+    def modelize_data_criteria_entry(entry)
+      criteria = entry.at_xpath('./*[xmlns:templateId/xmlns:item]')
+      model_fields =  if entry.at_css('localVariableName').present?
+                        extract_fields_from_standard_data_criteria(criteria, entry)
+                      else
+                        extract_fields_from_single_code_reference_data_criteria(criteria)
+                      end
+      hqmf_template_oid = criteria.at_css('templateId/item')['root']
+      model = QDM::ModelFinder.by_hqmf_oid(hqmf_template_oid)
+      raise "No datatype found for oid #{hqmf_template_oid}. Verify the QDM version of the measure package is correct." if model.nil?
+      model = model.new(model_fields)
+      model.description = model.qdmTitle + ': ' + model.description
+      return model
+    end
+
+    def extract_fields_from_standard_data_criteria(criteria, entry)
+      entry_variable_name_prefix = entry.at_css('localVariableName')['value'].split('_').first
+      node_with_valueset = (criteria.at_css('value[valueSet]') || criteria.at_css('code[valueSet]'))
+      code_list_id = node_with_valueset.present? ? node_with_valueset['valueSet'] : nil
+      return {
+        description: entry_variable_name_prefix,
+        codeListId: code_list_id
+      }
+    end
+
+    def extract_fields_from_single_code_reference_data_criteria(criteria)
+      single_code_reference = criteria.at_css('value[codeSystem][code]') || criteria.at_css('code[codeSystem][code]')
+      system_id = "#{single_code_reference['codeSystem']}_#{single_code_reference['codeSystemVersion']}".to_sym
+      concept = @single_code_concepts[system_id][single_code_reference['code'].to_sym] || get_concept_from_participation(criteria.at_css('participation'))
+      value_set = concept._parent
+      return {
+        description: concept.display_name,
+        codeListId: value_set.oid
+      }
+    end
+
+    # If QDM datatype template in MAT has includeSubTemplate, code gets nested into participation
+    # this method gets the codes from participation and form the code concept
+    def get_concept_from_participation(participation)
+      code_element = participation.at_css('code')
+      system_id = "#{code_element['codeSystem']}_#{code_element['codeSystemVersion']}".to_sym
+      @single_code_concepts[system_id][code_element['code'].to_sym]
+    end
+
+    def map_single_code_concepts(value_sets_from_single_code_references)
+      single_code_concepts = {}
+      value_sets_from_single_code_references.flat_map(&:concepts).each do |concept|
+        system_id = "#{concept.code_system_oid}_#{concept.code_system_version.to_s.sub('urn:hl7:version:','')}".to_sym
+        single_code_concepts[system_id] ||= {}
+        single_code_concepts[system_id][concept.code.to_sym] = concept
+      end
+      return single_code_concepts
+    end
+  end
+end