quality-measure-engine 2.5.3 → 3.0.0.beta.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NzQxMzZjMGM5NTAxM2Q0OWM1NjZhN2U4ZWY2YzQ4NzEzYThkZjc3YQ==
+    ODgyZTA5NDU0MGQ0NjZlOTc2YWYwZTYyYmE3OWZlZTUzNDNmYTYzOA==
   data.tar.gz: !binary |-
-    MjljNTk1NDBkNTFiYjY1M2ZjM2ZiM2QyNGY5MjE0YzhmZGIwZmEzOQ==
-SHA512:
+    ZjIwZDA5NTdkZWNjODBkYTMxNWY3YjA3ZWE3OWI3NTkwZTMwOTQxMQ==
+!binary "U0hBNTEy":
   metadata.gz: !binary |-
-    MWE3YTAwMTFlMzBiMzc2ODgyZWVhYTRhNGY5NTQ0MmNmNDkwMjVjODI3ZTg2
-    MzM4MjYwY2RmNzc4NDVhZTViZGVlMzI5YWMyYTVhNzdhZjhhNTI4ZWU1MjIy
-    Y2M3ZDI1Yjc5ZDgzMDcwMzNmZTA2ZGU0NjEzOWI0MTFmN2E5NzQ=
+    NTkxNTdlMWJiMzJjNDY0MjQxYjc0MjFjMGQyYTc4ZGZlZGU5ODhmNzIyMWI5
+    YWUxZDM0ODc5YzE0ZmI3OWRlMTg3ZWM5MWE5NDkyZGNkOTQ3YzI5ZWViNWUx
+    NzgzNWI0ZGQwZDE3MTk1MTU2N2ZjZjRhMGViMjY4MzIwNTFlZDM=
   data.tar.gz: !binary |-
-    ZjQ4ODgxN2ExMDQwYzgzMDY2MDMyMTg3ZTU3ZTEyNWZlY2I2Zjg3ZDNjYWFl
-    MmFlYzE5NjM4MjZhNDExNzAyNzliMDFhYTBlOTc0ZWNiMDU5NGYwNmM5MjI2
-    YjAxZmIxN2U5M2IxMTEwMjgxZGRhY2JjODIxY2RkMmNiNDQyOWE=
+    ZDMwZTJkYTlkMWRmZWM1ZTc2YzZlNjM1ZTdlYTU0YzNlYTlmZThiNzhlN2Zh
+    NTA3NmVjNTk0ZjkyNjZkODZlYTZkYTVhZjYxZGQxMDUzNjMyMTZiZDdiNDRi
+    NWFhMjg1NmY1NzEzMzQ3NDAyOTA2MmVkMDhmYjU5ZjllMzQwZTI=

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    quality-measure-engine (2.5.3)
+    quality-measure-engine (3.0.0.beta.1)
       delayed_job_mongoid (~> 2.0.0)
       mongoid (~> 3.1.4)
       moped (~> 1.5.1)
@@ -62,7 +62,7 @@ GEM
       treetop (~> 1.4.8)
     method_source (0.8.2)
     mime-types (1.24)
-    mini_portile (0.5.2)
+    mini_portile (0.5.1)
     minitest (4.7.5)
     mongoid (3.1.5)
       activemodel (~> 3.2)
@@ -70,7 +70,7 @@ GEM
       origin (~> 1.0)
       tzinfo (~> 0.3.29)
     moped (1.5.1)
-    multi_json (1.7.9)
+    multi_json (1.8.2)
     nokogiri (1.6.0)
       mini_portile (~> 0.5.0)
     origin (1.1.0)
@@ -131,7 +131,7 @@ GEM
       polyglot (>= 0.3.1)
     turn (0.9.6)
       ansi
-    tzinfo (0.3.37)
+    tzinfo (0.3.38)
 
 PLATFORMS
   ruby

data/lib/qme/database_access.rb

@@ -1,30 +1,10 @@
 module QME
-  module DatabaseAccess
-    
-    # Set up the information to connect to the database. Database host
-    # and port may be set using the environment variables TEST_DB_HOST
-    # and TEST_DB_PORT which default to localhost and 27017 respectively.
-    # @param [String] db_name the name of the database to use
-    def determine_connection_information(db_name = nil)
-      @db_name = ENV['DB_NAME'] || db_name || 'test'
-      @db_host = ENV['TEST_DB_HOST'] || 'localhost'
-      @db_port = ENV['TEST_DB_PORT'] ? ENV['TEST_DB_PORT'].to_i : 27017
-    end
-
+  module DatabaseAccess 
     # Lazily creates a connection to the database and initializes the
     # JavaScript environment
     # @return [Moped::Session]
     def get_db
-      if @db == nil
-        if @db_name==nil || @db_host==nil || @db_port==nil
-          determine_connection_information()
-        end
-        
-        @db = Moped::Session.new(["#{@db_host}:#{@db_port}"])
-        @db.use(@db_name)
-      end
-      
-      @db
+      Mongoid.default_session
     end
   end
 end

data/lib/qme/manual_exclusion.rb

@@ -0,0 +1,18 @@
+module QME
+  class ManualExclusion
+    include Mongoid::Document
+    store_in collection: 'manual_exclusions'
+    field :measure_id, type: String
+    field :sub_id, type: String
+    field :medical_record_id, type: String
+
+
+    def self.apply_manual_exclusions(measure_id, sub_id)
+      mids = where({measure_id: measure_id, sub_id: sub_id}).collect {|me| me.medical_record_id}
+      QME::PatientCache.where({'value.measure_id'=>@measure_id, 'value.sub_id'=>@sub_id, 'value.medical_record_id'=>{'$in'=>mids} })
+          .update_all({'$set'=>{'value.manual_exclusion'=>true}})
+    end
+
+  end
+end
+

data/lib/qme/map/map_reduce_builder.rb

@@ -66,8 +66,8 @@ module QME
           @params[name.to_s] = value
         end
         @measure_def = measure_def
-        @measure_def['parameters'] ||= {}
-        @measure_def['parameters'].each do |parameter, value|
+        @measure_def.parameters ||= {}
+        @measure_def.parameters.each do |parameter, value|
           if !@params.has_key?(parameter)
             raise "No value supplied for measure parameter: #{parameter}"
           end
@@ -75,17 +75,17 @@ module QME
         # if the map function is specified then replace any erb templates with their values
         # taken from the supplied params
         # always true for actual measures, not always true for unit tests
-        if (@measure_def['map_fn'])
-          template = ERB.new(@measure_def['map_fn'])
+        if (@measure_def.map_fn)
+          template = ERB.new(@measure_def.map_fn)
           context = Context.new(@db, @params)
-          @measure_def['map_fn'] = template.result(context.get_binding)
+          @measure_def.map_fn = template.result(context.get_binding)
         end
       end
 
       # Get the map function for the measure
       # @return [String] the map function
       def map_function
-        @measure_def['map_fn']
+        @measure_def.map_fn
       end
 
       # Get the reduce function for the measure, this is a simple
@@ -100,11 +100,11 @@ module QME
         if @params['test_id'] && @params['test_id'].class==Moped::BSON::ObjectId
           reduce += "  patient.test_id = new ObjectId(\"#{@params['test_id']}\");\n"
         end
-        if @measure_def['sub_id']
-          reduce += "  patient.sub_id = \"#{@measure_def['sub_id']}\";\n"
+        if @measure_def.sub_id
+          reduce += "  patient.sub_id = \"#{@measure_def.sub_id}\";\n"
         end
-        if @measure_def['nqf_id']
-          reduce += "  patient.nqf_id = \"#{@measure_def['nqf_id']}\";\n"
+        if @measure_def.nqf_id
+          reduce += "  patient.nqf_id = \"#{@measure_def.nqf_id}\";\n"
         end
           
         reduce += "patient.effective_date = #{@params['effective_date']};

data/lib/qme/map/map_reduce_executor.rb

@@ -15,18 +15,24 @@ module QME
       # @param [String] measure_id the measure identifier
       # @param [String] sub_id the measure sub-identifier or null if the measure is single numerator
       # @param [Hash] parameter_values a hash that may contain the following keys: 'effective_date' the measurement period end date, 'test_id' an identifier for a specific set of patients
-      def initialize(measure_id, sub_id, parameter_values)
+      def initialize(measure_id,sub_id, parameter_values)
+
         @measure_id = measure_id
-        @sub_id = sub_id
+        @sub_id =sub_id
+        
         @parameter_values = parameter_values
-        @measure_def = QualityMeasure.new(@measure_id, @sub_id, parameter_values['bundle_id']).definition
-        determine_connection_information()
+        q_filter = {hqmf_id: @measure_id,sub_id: @sub_id}
+        if @parameter_values.keys.index("bundle_id")
+          q_filter["bundle_id"] == @parameter_values['bundle_id']
+          @bundle_id = @parameter_values['bundle_id']
+        end  
+        @measure_def = QualityMeasure.where(q_filter).first
       end
 
       def build_query
         pipeline = []
 
-        filters = @parameter_values['filters']
+        filters = @parameter_values["filters"]
 
         
         match = {'value.measure_id' => @measure_id, 
@@ -77,7 +83,7 @@ module QME
                  'value.test_id'          => @parameter_values['test_id'],
                  'value.manual_exclusion' => {'$in' => [nil, false]}}    
        
-        keys = @measure_def["population_ids"].keys - [QME::QualityReport::OBSERVATION, "stratification"]
+        keys = @measure_def.population_ids.keys - [QME::QualityReport::OBSERVATION, "stratification"]
         supplemental_data = Hash[*keys.map{|k| [k,{QME::QualityReport::RACE => {},
                                                    QME::QualityReport::ETHNICITY => {},
                                                    QME::QualityReport::SEX => {},
@@ -131,24 +137,26 @@ module QME
           raise RuntimeError, "Expected one group from patient_cache aggregation, got #{aggregate['result'].size}"
         end
 
-        nqf_id = @measure_def['nqf_id'] || @measure_def['id']
-        result = {:measure_id => @measure_id, :sub_id => @sub_id, :nqf_id => nqf_id, :population_ids => @measure_def["population_ids"],
-                  :effective_date => @parameter_values['effective_date'],
-                  :test_id => @parameter_values['test_id'], :filters => @parameter_values['filters']}
+        nqf_id = @measure_def.nqf_id || @measure_def['id']
+        result = QME::QualityReportResult.new
+        result.population_ids=@measure_def.population_ids
+
 
-        if @measure_def['continuous_variable']
+        if @measure_def.continuous_variable
           aggregated_value = calculate_cv_aggregation 
           result[QME::QualityReport::OBSERVATION] = aggregated_value
         end
 
-        result.merge!(aggregate['result'].first)
-        result.reject! {|k, v| k == '_id'} # get rid of the group id the Mongo forced us to use
+        agg_result = aggregate['result'].first
+        agg_result.reject! {|k, v| k == '_id'} # get rid of the group id the Mongo forced us to use
         # result['exclusions'] += get_db['patient_cache'].find(base_query.merge({'value.manual_exclusion'=>true})).count
-        result.merge!(execution_time: (Time.now.to_i - @parameter_values['start_time'].to_i)) if @parameter_values['start_time']
-        result[:supplemental_data] = self.calculate_supplemental_data_elements
-        get_db()["query_cache"].insert(result)
-        get_db().command({:getLastError => 1}) # make sure last insert finished before we continue
+        agg_result.merge!(execution_time: (Time.now.to_i - @parameter_values['start_time'].to_i)) if @parameter_values['start_time']
+        agg_result.each_pair do |k,v|
+          result[k]=v
+        end
+        result.supplemental_data = self.calculate_supplemental_data_elements
         result
+
       end
 
       # This method calculates the aggregated value for a CV measure.  It extracts all 
@@ -170,7 +178,7 @@ module QME
         aggregate['result'].each do |freq_count_pair|
           frequencies[freq_count_pair['_id']] = freq_count_pair['count']
         end
-        QME::MapReduce::CVAggregator.send(@measure_def['aggregator'].parameterize, frequencies)
+        QME::MapReduce::CVAggregator.send(@measure_def.aggregator.parameterize, frequencies)
       end
 
 
@@ -185,7 +193,7 @@ module QME
                          :out => {:reduce => 'patient_cache'}, 
                          :finalize => measure.finalize_function,
                          :query => {:test_id => @parameter_values['test_id']})
-        apply_manual_exclusions
+        QME::ManualExclusion.apply_manual_exclusions(@measure_id,@sub_id)
       end
       
       # This method runs the MapReduce job for the measure and a specific patient.
@@ -198,8 +206,9 @@ module QME
                          :reduce => "function(key, values){return values;}",
                          :out => {:reduce => 'patient_cache'}, 
                          :finalize => measure.finalize_function,
-                         :query => {:medical_record_number => patient_id, :test_id => @parameter_values['test_id']})
-        apply_manual_exclusions
+                         :query => {:medical_record_number => patient_id, :test_id => @parameter_values["test_id"]})
+        QME::ManualExclusion.apply_manual_exclusions(@measure_id,@sub_id)
+
       end
       
       # This method runs the MapReduce job for the measure and a specific patient.
@@ -212,22 +221,13 @@ module QME
                                   :reduce => "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']})
+                                  :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
-        exclusions = get_db()['manual_exclusions'].find({'measure_id'=>@measure_id, 'sub_id'=>@sub_id}).to_a.map do |exclusion|
-          exclusion['medical_record_id']
-        end
-        get_db()['patient_cache'].find({'value.measure_id'=>@measure_id, 'value.sub_id'=>@sub_id, 'value.medical_record_id'=>{'$in'=>exclusions} })
-          .update_all({'$set'=>{'value.manual_exclusion'=>true}})
-      end
+
     end
   end
 end

data/lib/qme/map/measure_calculation_job.rb

@@ -2,30 +2,27 @@ module QME
   module MapReduce
     # A delayed_job that allows for measure calculation by a delayed_job worker. Can be created as follows:
     #
-    #     Delayed::Job.enqueue QME::MapRedude::MeasureCalculationJob.new(:measure_id => '0221', :sub_id => 'a', :effective_date => 1291352400, :test_id => xyzzy)
+    #     Delayed::Job.enqueue QME::MapRedude::MeasureCalculationJob.new(quality_report, :effective_date => 1291352400, :test_id => xyzzy)
     #
-    # MeasureCalculationJob will check to see if a measure has been calculated before running the calculation. It does
-    # this by creating a QME::QualityReport and asking if it has been calculated. If so, it will complete the job without
-    # running the MapReduce job.
+    # MeasureCalculationJob will check to see if a measure has been calculated before running the calculation. It will do this by 
+    # checking the status of the quality report that this calculation job was created with.
     #
     # When a measure needs calculation, the job will create a QME::MapReduce::Executor and interact with it to calculate
     # the report.
     class MeasureCalculationJob
-      attr_accessor :test_id, :measure_id, :sub_id, :effective_date, :filters
+      attr_accessor :quality_report
 
       def initialize(options)
-        @measure_id = options['measure_id']
-        @sub_id = options['sub_id']
+        @quality_report = QME::QualityReport.find(options["quality_report_id"])
         @options = options
+        @options.merge! @quality_report.attributes
       end
       
       def perform
-        qr = QualityReport.new(@measure_id, @sub_id, @options)
-        if qr.calculated?
-          completed("#{@measure_id}#{@sub_id} has already been calculated")
-        else
-          map = QME::MapReduce::Executor.new(@measure_id, @sub_id, @options.merge('start_time' => Time.now.to_i))
-          if !qr.patients_cached?
+
+        if !@quality_report.calculated?
+          map = QME::MapReduce::Executor.new(@quality_report.measure_id,@quality_report.sub_id, @options.merge('start_time' => Time.now.to_i))
+          if !@quality_report.patients_cached?
             tick('Starting MapReduce')
             map.map_records_into_measure_groups
             tick('MapReduce complete')
@@ -33,17 +30,74 @@ module QME
           
           tick('Calculating group totals')
           result = map.count_records_in_measure_groups
+          @quality_report.result=result
+          # backwards compatibility with previous q cahce users.  Should be reomved going foward 
+          # and provide a means to update existing results to the newer format
+          result.attributes.each_pair do |k,v|
+            unless k.to_s == "_id"
+              @quality_report[k]=v
+            end
+          end
+          @quality_report.save
           completed("#{@measure_id}#{@sub_id}: p#{result[QME::QualityReport::POPULATION]}, d#{result[QME::QualityReport::DENOMINATOR]}, n#{result[QME::QualityReport::NUMERATOR]}, excl#{result[QME::QualityReport::EXCLUSIONS]}, excep#{result[QME::QualityReport::EXCEPTIONS]}")
         end
       end
 
       def completed(message)
-        
+        @quality_report.status["state"] = "completed"
+        @quality_report.status["log"] << message
+        @quality_report.calculation_time = Time.now
+        @quality_report.save
       end
 
       def tick(message)
-        
+        @quality_report.status["state"] = "calculating"
+        @quality_report.status["log"] << message
+        @quality_report.save
+      end
+
+      def enqueue(job)
+        @quality_report.status = {"state" => "queued", "log" => ["Queued at #{Time.now}"], "job_id" => job.id} 
       end
+
+
+      def error(job, exception)
+        @quality_report.status["state"] = "error"
+        @quality_report.status["log"] << exception.to_s
+        @quality_report.save
+      end
+
+      def failure(job)
+        @quality_report.status["state"] = "failed"
+        @quality_report.status["log"] << "Failed at #{Time.now}"
+        @quality_report.save
+      end
+
+      def after(job)
+        @quality_report.status.delete("job_id")
+        @quality_report.save
+      end
+
+    # Returns the status of a measure calculation job
+    # @param job_id the id of the job to check on
+    # @return [Symbol] Will return the status: :complete, :queued, :running, :failed
+    def self.status(job_id)
+      job = Delayed::Job.where(_id: job_id).first
+      if job.nil?
+        # If we can't find the job, we assume that it is complete
+        :complete
+      else
+        if job.locked_at.nil?
+          :queued
+        else
+          if job.failed?
+            :failed
+          else
+            :running
+          end            
+        end
+      end
+    end
     end
   end
 end

data/lib/qme/patient_cache.rb

@@ -0,0 +1,31 @@
+ module QME
+  class PatientCache
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    store_in collection: 'patient_cache'
+    index "value.last" => 1
+    index "bundle_id" => 1
+    embeds_one :value, class_name: "QME::PatientCacheValue", inverse_of: :patient_cache
+  end
+
+  class PatientCacheValue
+
+    include Mongoid::Document
+
+    embedded_in :patient_cache, inverse_of: :value
+
+    field :filters, type: Hash
+    field :manual_exclusion, type: Boolean, default: false
+    field :DENOM, type: Integer
+    field :NUMER, type: Integer
+    field :DENEX, type: Integer
+    field :DENEXCEP, type: Integer
+    field :MSRPOPL, type: Integer
+    field :OBSERV
+    field :antinumerator, type: Integer
+    field :IPP, type: Integer
+    field :measure_id, type: String
+    field :sub_id, type: String
+  end
+end
+

data/lib/qme/quality_measure.rb

@@ -1,61 +1,17 @@
 module QME
   class QualityMeasure
-    include DatabaseAccess
-    extend DatabaseAccess
-    determine_connection_information
     
-    # Return a list of the measures in the database
-    # @return [Hash] an hash of measure definitions
-    def self.all(bundle_id = nil)
-      result = {}
-      measures = query_measures({}, bundle_id)
-      measures.find_all.each do |measure|
-        id = measure['id']
-        sub_id = measure['sub_id']
-        measure_id = "#{id}#{sub_id}.json"
-        result[measure_id] ||= measure
-      end
-      result
-    end
-    
-    def self.get_measures(measure_ids, bundle_id = nil)
-      query_measures({'id' => {"$in" => measure_ids}}, bundle_id)
-    end
-
-    def self.get(measure_id, sub_id, bundle_id = nil)
-      query_measures({'id' => measure_id, 'sub_id' => sub_id}, bundle_id)
-    end
-
-    def self.sub_measures(measure_id, bundle_id = nil)
-      query_measures({'id' => measure_id}, bundle_id)
-    end
-    
-    # Creates a new QualityMeasure
-    # @param [String] measure_id value of the measure's id field
-    # @param [String] sub_id value of the measure's sub_id field, may be nil for measures with only a single numerator and denominator
-    def initialize(measure_id, sub_id = nil, bundle_id = nil)
-      @measure_id = measure_id
-      @sub_id = sub_id
-      @bundle_id = bundle_id
-      determine_connection_information
-    end
-    
-    # Retrieve a measure definition from the database
-    # @return [Hash] a JSON hash of the encoded measure
-    def definition
-      if @sub_id
-        QME::QualityMeasure.query_measures({'id' => @measure_id, 'sub_id' => @sub_id}, @bundle_id).first()
-      else
-        QME::QualityMeasure.query_measures({'id' => @measure_id}, @bundle_id).first()
-      end
-    end
+    include Mongoid::Document
+    store_in collection: 'measures'
 
-    # Build measure collection query. Allows scoping of query to a single bundle
-    # @param [String] criteria Moped query hash
-    # @param [String] bundle_id the MongoDB id of the bundle to scope the query against. Leaving this as nil will scope to all bundles
-    def self.query_measures(criteria, bundle_id=nil)
-      criteria = bundle_id ? criteria.merge!({'bundle_id' => bundle_id}): criteria
-      get_db()['measures'].find(criteria)
-    end
+    field :id, type: String
+    field :sub_id, type: String
+    field :map_fn, type: String
+    field :nqf_id, type: String
+    field :continuous_variable, type: Boolean, default: false
+    field :aggregator, type: String
+    field :map_fn, type: String
+    field :population_ids, type: Hash
+    field :parameters, type: Hash, default: {}
   end
 end