quality-measure-engine 1.0.4 → 1.1.0

data/Gemfile

@@ -5,11 +5,12 @@ gemspec :development_group => :test
 gem 'mongo', '1.5.1'
 gem 'bson_ext', '1.5.1',  :platforms => :mri
 gem 'rake'
-gem 'pry', :require => true
+#gem 'pry', :require => true
+#gem 'health-data-standards', :git => 'https://github.com/projectcypress/health-data-standards.git', :branch => 'master'
+gem 'health-data-standards', '0.7.0'
 
 group :test do
   gem 'cover_me', '>= 1.0.0.rc5', :platforms => :ruby_19
-  gem 'metric_fu'
   gem 'sinatra'
 end
 

data/Rakefile

@@ -1,6 +1,5 @@
 require 'rspec/core/rake_task'
 require 'yard'
-require 'metric_fu'
 require 'resque/tasks'
 
 ENV['MEASURE_DIR'] = ENV['MEASURE_DIR'] || File.join('fixtures', 'measure_defs')
@@ -29,11 +28,4 @@ end
 task :coverage do
   Rake::Task['spec'].invoke
   Rake::Task['cover_me:report'].invoke
-end
-
-MetricFu::Configuration.run do |config|
-    #define which metrics you want to use
-    config.metrics  = [:roodi, :reek, :churn, :flog, :flay]
-    config.graphs   = [:flog, :flay]
-    config.flay ={:dirs_to_flay => []} #Flay doesn't seem to be handling CLI arguments well... so this config squashes them
 end

data/VERSION

@@ -1 +1 @@
-1.0.4
+1.1.0

data/js/map_reduce_utils.js

@@ -120,7 +120,7 @@ function() {
   root.map = function(record, population, denominator, numerator, exclusion) {
     var value = {population: false, denominator: false, numerator: false, 
                  exclusions: false, antinumerator: false, patient_id: record._id,
-                 medical_record_id: record.patient_id,
+                 medical_record_id: record.medical_record_number,
                  first: record.first, last: record.last, gender: record.gender,
                  birthdate: record.birthdate, test_id: record.test_id,
                  provider_performances: record.provider_performances,

data/lib/qme/database_access.rb

@@ -24,6 +24,10 @@ module QME
       if @db == nil
         @db = Mongo::Connection.new(@db_host, @db_port).db(@db_name)
       end
+      Mongoid.configure do |config|
+        config.master = Mongo::Connection.new(@db_host, @db_port).db(@db_name)
+      end
+      
       @db
     end
   end

data/lib/qme/ext/record.rb

@@ -0,0 +1,49 @@
+# Extensions to the Record model in health-data-standards to support
+# quality measure calculation
+class Record
+  extend ActiveSupport::Memoizable
+  
+  def procedure_results
+    results.to_a + vital_signs.to_a + procedures.to_a
+  end
+  
+  def laboratory_tests
+    results.to_a + vital_signs.to_a
+  end
+  
+  def all_meds
+    medications.to_a + immunizations.to_a
+  end
+  
+  def active_diagnosis
+    conditions.any_of({:status => 'active'}, {:status => nil}).to_a + 
+    social_history.any_of({:status => 'active'}, {:status => nil}).to_a
+  end
+  
+  def inactive_diagnosis
+    conditions.any_of({:status => 'inactive'}, {:status => nil}).to_a + 
+    social_history.any_of({:status => 'inactive'}, {:status => nil}).to_a
+  end
+  
+  def resolved_diagnosis
+    conditions.any_of({:status => 'resolved'}, {:status => nil}).to_a + 
+    social_history.any_of({:status => 'resolved'}, {:status => nil}).to_a
+  end
+  
+  def all_problems
+    conditions.to_a + social_history.to_a
+  end
+  
+  def all_devices
+    conditions.to_a + procedures.to_a + care_goals.to_a + medical_equipment.to_a
+  end
+  
+  memoize :procedure_results
+  memoize :laboratory_tests
+  memoize :all_meds
+  memoize :active_diagnosis
+  memoize :inactive_diagnosis
+  memoize :resolved_diagnosis
+  memoize :all_problems
+  memoize :all_devices
+end

data/lib/qme/importer/entry.rb

@@ -91,7 +91,7 @@ module QME
       # Creates a Hash for this Entry
       # @return [Hash] a Hash representing the Entry
       def to_hash
-        entry_hash = {}
+        entry_hash = {'_id' => BSON::ObjectId.new}
         entry_hash['codes'] = @codes
         unless @value.empty?
           entry_hash['value'] = @value

data/lib/qme/importer/generic_importer.rb

@@ -23,13 +23,12 @@ module QME
       #
       # @param [Hash] patient_hash representation of a patient
       # @return [Hash] measure information
-      def parse(patient_hash)
+      def parse(patient)
         measure_info = {}
         @definition['measure'].each_pair do |property, description|
           raise "No standard_category for #{property}" if !description['standard_category']
           matcher = PropertyMatcher.new(description)
-          enrty_filter = filter_for_property(description['standard_category'], description['qds_data_type'])
-          entry_list = enrty_filter.call(patient_hash)
+          entry_list = filter_for_property(description['standard_category'], description['qds_data_type'], patient)
           if ! entry_list.empty?
             matched_list = matcher.match(entry_list)
             measure_info[property] = matched_list if matched_list.length > 0
@@ -40,89 +39,67 @@ module QME
 
       private
 
-      def create_section_filter(*sections)
-        Proc.new do |patient_hash|
-          sections.map do |section|
-            if patient_hash[section]
-              patient_hash[section]
-            else
-              []
-            end
-          end.flatten
-        end
-      end
-
-      def create_section_and_status_filter(status, *sections)
-        section_filter = create_section_filter(*sections)
-        Proc.new do |patient_hash|
-          entry_list = section_filter.call(patient_hash)
-          entry_list.select do |entry|
-            entry.status.nil? || entry.status == status
-          end
-        end
-      end
-
-      def filter_for_property(standard_category, qds_data_type)
+      def filter_for_property(standard_category, qds_data_type, patient)
         # Currently unsupported categories: negation_rationale, risk_category_assessment
         case standard_category
         when 'encounter'
-          create_section_filter(:encounters)
+          patient.encounters
         when 'procedure'
           case qds_data_type
           when 'procedure_performed'
-            create_section_filter(:procedures)
+            patient.procedures
           when 'procedure_adverse_event', 'procedure_intolerance'
-            create_section_filter(:allergies)
+            patient.allergies
           when 'procedure_result'
-            create_section_filter(:procedures, :results, :vital_signs)
+            patient.procedure_results
           end
         when 'risk_category_assessment'
-          create_section_filter(:procedures)
+          patient.procedures
         when 'communication'
-          create_section_filter(:procedures)
+          patient.procedures
         when 'laboratory_test'
-          create_section_filter(:results, :vital_signs)
+          patient.laboratory_tests
         when 'physical_exam'
-          create_section_filter(:vital_signs)
+          patient.vital_signs
         when 'medication'
           case qds_data_type
           when 'medication_dispensed', 'medication_order', 'medication_active', 'medication_administered'
-            create_section_filter(:medications, :immunizations)
+            patient.all_meds
           when 'medication_allergy', 'medication_intolerance', 'medication_adverse_event'
-            create_section_filter(:allergies)
+            patient.allergies
           end
         when 'diagnosis_condition_problem'
           case qds_data_type
           when 'diagnosis_active'
-            create_section_and_status_filter(:active, :conditions, :social_history)
+            patient.active_diagnosis
           when 'diagnosis_inactive'
-            create_section_and_status_filter(:inactive, :conditions, :social_history)
+            patient.inactive_diagnosis
           when 'diagnosis_resolved'
-            create_section_and_status_filter(:resolved, :conditions, :social_history)
+            patient.resolved_diagnosis
           end
         when 'symptom'
-          create_section_filter(:conditions, :social_history)
+          patient.all_problems
         when 'individual_characteristic'
-          create_section_filter(:conditions, :social_history)
+          patient.all_problems
         when 'device'
           case qds_data_type
           when 'device_applied'
-            create_section_filter(:conditions, :procedures, :care_goals, :medical_equipment)
+            patient.all_devices
           when 'device_allergy'
-            create_section_filter(:allergies)
+            patient.allergies
           end
         when 'care_goal'
-          create_section_filter(:care_goals)
+          patient.care_goals
         when 'diagnostic_study'
-          create_section_filter(:procedures)
+          patient.procedures
         when 'substance'
-          create_section_filter(:allergies)
+          patient.allergies
         else
           unless self.class.warnings.include?(standard_category)
             puts "Warning: Unsupported standard_category (#{standard_category})"
             self.class.warnings << standard_category
           end
-          Proc.new {[]} # A proc that returns an empty array
+          []
         end
       end
     end

data/lib/qme/importer/measure_properties_generator.rb

@@ -0,0 +1,39 @@
+module QME
+  module Importer
+    class MeasurePropertiesGenerator
+      include Singleton
+      
+      def initialize
+        @measure_importers = {}
+      end
+      
+      # Adds a GenericImporter that will be used to extract
+      # information about a measure from a patient Record.
+      def add_measure(measure_id, importer)
+        @measure_importers[measure_id] = importer
+      end
+      
+      # Generates denormalized measure information
+      # Measure information is contained in a Hash that hash
+      # the measure id as a key, and the denormalized
+      # measure information as a value
+      #
+      # @param [Record] patient - populated patient record
+      # @returns Hash with denormalized measure information
+      def generate_properties(patient)
+        measures = {}
+        @measure_importers.each_pair do |measure_id, importer|
+          measures[measure_id] = importer.parse(patient)
+        end
+        measures
+      end
+      
+      # The same as generate_properties but addes the denormalized
+      # measure information into the Record and saves it.
+      def generate_properties!(patient)
+        patient['measures'] = generate_properties(patient)
+        patient.save!
+      end
+    end
+  end
+end

data/lib/qme/importer/provider_importer.rb

@@ -11,16 +11,19 @@ module QME
       # @param [Nokogiri::XML::Document] doc It is expected that the root node of this document
       #        will have the "cda" namespace registered to "urn:hl7-org:v3"
       # @return [Array] an array of providers found in the document
-      def extract_providers(doc)
-        
-        performers = doc.xpath("//cda:documentationOf/cda:serviceEvent/cda:performer")
+      def extract_providers(doc, use_encounters=false)
         
+
+        xpath_base = use_encounters ? "//cda:encounter/cda:performer" : "//cda:documentationOf/cda:serviceEvent/cda:performer"
+  
+        performers = doc.xpath(xpath_base)
+
         providers = performers.map do |performer|
           provider = {}
           entity = performer.xpath(performer, "./cda:assignedEntity")
           name = entity.xpath("./cda:assignedPerson/cda:name")
           provider[:title]        = extract_data(name, "./cda:prefix")
-          provider[:given_name]   = extract_data(name, "./cda:given")
+          provider[:given_name]   = extract_data(name, "./cda:given[1]")
           provider[:family_name]  = extract_data(name, "./cda:family")
           provider[:phone]        = extract_data(entity, "./cda:telecom/@value") { |text| text.gsub("tel:", "") }
           provider[:organization] = extract_data(entity, "./cda:representedOrganization/cda:name")

data/lib/qme/map/map_reduce_builder.rb

@@ -97,7 +97,7 @@ module QME
                      var tmp = [];
                      for(var i=0; i<patient.provider_performances.length; i++) {
                        var value = patient.provider_performances[i];
-                       if (value['start_date'] <= #{@params['effective_date']} && (value['end_date'] >= #{@params['effective_date']} || value['end_date'] == null))
+                       if ((value['start_date'] <= #{@params['effective_date']} || value['start_date'] == null) && (value['end_date'] >= #{@params['effective_date']} || value['end_date'] == null))
                        tmp.push(value);
                      }
                      if (tmp.length == 0) tmp = null;

data/lib/qme/map/map_reduce_executor.rb

@@ -32,36 +32,24 @@ module QME
         base_query.merge!(filter_parameters)
         
         query = base_query.clone
-        
-        query.merge!({'value.manual_exclusion'=>{'$ne'=>true}})
+
+        query.merge!({'value.manual_exclusion' => {'$in' => [nil, false]}})
         
         result = {:measure_id => @measure_id, :sub_id => @sub_id, 
                   :effective_date => @parameter_values['effective_date'],
                   :test_id => @parameter_values['test_id'], :filters => @parameter_values['filters']}
         
-        aggregate = patient_cache.group({cond: query, 
-                                            initial: {population: 0, denominator: 0, numerator: 0, antinumerator: 0,  exclusions: 0, considered: 0}, 
-                                            reduce: "function(record,sums) {
-                                                       for (var key in sums) {
-                                                           sums[key] += (record['value'][key] || key == 'considered') ? 1 : 0
-                                                       }
-                                                     }"}).first
-         
-         aggregate ||= {"population"=>0, "denominator"=>0, "numerator"=>0, "antinumerator"=>0, "exclusions"=>0}
-         aggregate.each {|key, value| aggregate[key] = value.to_i}
-         aggregate['exclusions'] += patient_cache.find(base_query.merge({'value.manual_exclusion'=>true})).count
+         # need to time the old way agains the single query to verify that the single query is more performant
+         aggregate = {"population"=>0, "denominator"=>0, "numerator"=>0, "antinumerator"=>0,  "exclusions"=>0}
+         %w(population denominator numerator antinumerator exclusions).each do |measure_group|
+           patient_cache.find(query.merge("value.#{measure_group}" => true)) do |cursor|
+             aggregate[measure_group] = cursor.count
+           end
+         end
+         aggregate["considered"] = patient_cache.find(query).count
+         aggregate["exclusions"] += patient_cache.find(base_query.merge({'value.manual_exclusion'=>true})).count
          result.merge!(aggregate)
 
-        # # need to time the old way agains the single query to verify that the single query is more performant        
-        # aggregate = {population: 0, denominator: 0, numerator: 0, antinumerator: 0,  exclusions: 0}
-        # %w(population denominator numerator antinumerator exclusions).each do |measure_group|
-        #   patient_cache.find(query.merge("value.#{measure_group}" => true)) do |cursor|
-        #     aggregate[measure_group] = cursor.count
-        #   end
-        # end
-        # aggregate[:considered] = patient_cache.find(query).count
-        # result.merge!(aggregate)
-
         result.merge!(execution_time: (Time.now.to_i - @parameter_values['start_time'].to_i)) if @parameter_values['start_time']
 
         get_db.collection("query_cache").save(result, safe: true)
@@ -92,11 +80,27 @@ module QME
         records.map_reduce(measure.map_function, "function(key, values){return values;}",
                            :out => {:reduce => 'patient_cache'}, 
                            :finalize => measure.finalize_function,
-                           :query => {:patient_id => patient_id, :test_id => @parameter_values['test_id']})
+                           :query => {:medical_record_number => patient_id, :test_id => @parameter_values['test_id']})
         apply_manual_exclusions
       end
       
-      # This records collects the set of manual exclusions from the manual_exclusions collections
+      # This method runs the MapReduce job for the measure and a specific patient.
+      # This will *not* create a document in the patient_cache collection, instead the
+      # result is returned directly.
+      def get_patient_result(patient_id)
+        qm = QualityMeasure.new(@measure_id, @sub_id)
+        measure = Builder.new(get_db, qm.definition, @parameter_values)
+        records = get_db.collection('records')
+        result = records.map_reduce(measure.map_function, "function(key, values){return values;}",
+                           :out => {:inline => true}, 
+                           :raw => true, 
+                           :finalize => measure.finalize_function,
+                           :query => {:medical_record_number => patient_id, :test_id => @parameter_values['test_id']})
+        raise result['err'] if result['ok']!=1
+        result['results'][0]['value']
+      end
+      
+      # This collects the set of manual exclusions from the manual_exclusions collections
       # and sets a flag in each cached patient result for patients that have been excluded from the
       # current measure
       def apply_manual_exclusions

data/lib/qme/randomizer/patient_randomization_job.rb

@@ -24,21 +24,20 @@ module QME
         QME::QualityMeasure.all.each_value do |measure_def|
           measure_id = measure_def['id']
           if !processed_measures[measure_id]
-            QME::Importer::PatientImporter.instance.add_measure(measure_id, QME::Importer::GenericImporter.new(measure_def))
-            processed_measures[measure_id]=true
+            QME::Importer::MeasurePropertiesGenerator.instance.add_measure(measure_id, QME::Importer::GenericImporter.new(measure_def))
+            processed_measures[measure_id] = true
           end
         end
 
-        loader = QME::Database::Loader.new()
         tick('Generating patients')
         count.times do |i|
           at(i, count, "Generating patient #{i} of #{count}")
           template = templates[rand(templates.length)]
           generator = QME::Randomizer::Patient.new(template)
           json = JSON.parse(generator.get())
-          patient_record_hash = QME::Importer::PatientImporter.instance.parse_hash(json)
-          patient_record_hash['test_id'] = test_id
-          loader.save('records', patient_record_hash)
+          patient_record = RandomPatientCreator.parse_hash(json)
+          patient_record.test_id = test_id
+          patient_record.save!
         end
 
         completed

data/lib/qme/randomizer/random_patient_creator.rb

@@ -0,0 +1,47 @@
+module QME
+  module Randomizer
+    class RandomPatientCreator
+      
+      # Parses a patient hash containing demographic and event information
+      #
+      # @param [Hash] patient_hash patient data
+      # @return [Record] a representation of the patient that can be inserted into MongoDB
+      def self.parse_hash(patient_hash)
+        patient_record = Record.new
+        patient_record.first = patient_hash['first']
+        patient_record.last = patient_hash['last']
+        patient_record.gender = patient_hash['gender']
+        patient_record.medical_record_number = patient_hash['medical_record_number']
+        patient_record.birthdate = patient_hash['birthdate']
+        patient_record.race = patient_hash['race']
+        patient_record.ethnicity = patient_hash['ethnicity']
+        # pophealth needs languages... please do not remove
+        patient_record.languages = patient_hash['languages']
+        #patient_record['addresses'] = patient_hash['addresses']
+        patient_hash['events'].each do |key, value|
+          patient_record.send("#{key}=".to_sym, parse_events(value))
+        end
+        patient_record['measures'] = QME::Importer::MeasurePropertiesGenerator.instance.generate_properties(patient_record)
+        
+        patient_record
+      end
+      
+      # Parses a list of event hashes into an array of Entry objects
+      #
+      # @param [Array] event_list list of event hashes
+      # @return [Array] array of Entry objects
+      def self.parse_events(event_list)
+        event_list.collect do |event|
+          if event.class==String.class
+            # skip String elements in the event list, patient randomization templates
+            # introduce String elements to simplify tailing-comma handling when generating
+            # JSON using ERb
+            nil
+          else
+            Entry.from_event_hash(event)
+          end
+        end.compact
+      end
+    end
+  end
+end