quality-measure-engine 1.1.5 → 2.0.0

data/lib/tasks/measure.rake

@@ -1,110 +0,0 @@
-path = File.dirname(__FILE__)
-path = path.index('lib') == 0 ? "./#{path}" : path
-require 'json'
-require 'zlib'
-gem 'rubyzip'
-require 'zip/zip'
-require 'zip/zipfilesystem'
-require File.join(path,'../quality-measure-engine')
-measures_dir = ENV['MEASURE_DIR'] || 'measures'
-bundle_dir = ENV['BUNDLE_DIR'] || './'
-xls_dir = ENV['XLS_DIR'] || 'xls'
-db_name = ENV['DB_NAME'] || 'test'
-
-namespace :measures do
-  
-  desc 'Build all measures to tmp directory'
-  task :build do
-    puts "Loading measures from #{measures_dir}"
-    dest_dir = File.join('.', 'tmp')
-    Dir.mkdir(dest_dir) if !Dir.exist?(dest_dir)
-    Dir.glob(File.join(measures_dir, '*')).each do |measure_dir|
-      measures = QME::Measure::Loader.load_measure(measure_dir)
-      measures.each do |measure|
-        id = measure['id']
-        sub_id = measure['sub_id']
-        json = JSON.pretty_generate(measure)
-        file_name = File.join(dest_dir, "#{id}#{sub_id}.json")
-        file = File.new(file_name,  "w")
-        file.write(json)
-        file.close
-      end
-    end
-  end
-  
-  desc "run the map_test tool"
-  task :map_tool do
-    puts "Loading measures from #{measures_dir}"
-    require File.join(path,"../../map_test/map_test.rb")
-  end
-  
-  desc 'Take a snapshot of the current measures, system.js and bundles collections and store as a ZIP file'
-  task :snapshot do
-    tmp = File.join('.', 'tmp')
-    dest_dir = File.join(tmp, 'bundle')
-    FileUtils.rm_r dest_dir, :force=>true
-    FileUtils.mkdir_p(dest_dir)
-    system("mongodump --db #{db_name} --collection bundles --out - > #{dest_dir}/bundles.bson")
-    system("mongodump --db #{db_name} --collection system.js --out - > #{dest_dir}/system.js.bson")
-    system("mongodump --db #{db_name} --collection measures --out - > #{dest_dir}/measures.bson")
-    read_me = <<EOF
-Load the included files into Mongo as follows:
-
-mongorestore --db dbname --drop measures.bson
-mongorestore --db dbname --drop bundles.bson
-mongorestore --db dbname --drop system.js.bson
-
-Where dbname is the name of the database you want to load the measures into. For a
-production system this will typically be pophealth-production. For a development
-system it will typically be pophealth-development.
-
-Note that the existing contents of the destination database's measures, system.js and
-bundles collections will be lost.
-EOF
-    File.open(File.join(dest_dir, 'README.txt'), 'w') {|f| f.write(read_me) }
-    
-    archive = File.join(tmp, 'bundle.zip')
-    puts "Snapshot saved to #{archive}"
-    FileUtils.rm archive, :force=>true
-    
-    Zip::ZipFile.open(archive, 'w') do |zipfile|
-      Dir["#{dest_dir}/*"].each do |file|
-        zipfile.add(File.basename(file),file)
-      end
-    end    
-    FileUtils.rm_r dest_dir, :force=>true
-  end
-  
-  desc "convert NQF Excel spreadsheets to JSON"
-  task :convert do
-    require LIB + '/qme/measure/properties_builder'
-    require LIB + '/qme/measure/properties_converter'
-    dest_dir = File.join('.', 'tmp')    
-    Dir.mkdir(dest_dir) if !Dir.exist?(dest_dir)
-    Dir.glob(File.join(xls_dir, '*.xlsx')).each do |measure|
-      properties = QME::Measure::Converter.from_xls(measure)
-      json = JSON.pretty_generate(properties)
-      file_name = File.join(dest_dir, "#{File.basename(measure)}.json")
-      file = File.new(file_name,  "w")
-      file.write(json)
-      file.close
-    end
-  end
-  
-  desc "export results of measures (expects date in YYYY-MM-DD format)"
-  task :export_results, :effective_date do |t, args|
-    measure_ids = ENV["MEASURES"].split(",")
-    measures = QME::QualityMeasure.get_measures(measure_ids)
-    effective_date_s = args[:effective_date] || "2010-12-31"
-    effective_date = Time.parse(effective_date_s).to_i
-    measures.each do |measure|
-      qr = QME::QualityReport.new(measure['id'], measure['sub_id'], 'effective_date' => effective_date)
-      qr.calculate(false) unless qr.calculated?
-      r = qr.result
-      
-      puts "#{measure['id']}#{measure['sub_id']}: #{r['numerator']}/#{r['denominator']}/#{r['population']} (#{r['exclusions']})"
-    end
-  end
-  
-
-end

data/lib/tasks/mongo.rake

@@ -1,68 +0,0 @@
-path = File.dirname(__FILE__)
-path = path.index('lib') == 0 ? "./#{path}" : path
-require 'mongo'
-require 'json'
-require 'resque'
-require File.join(path,'../quality-measure-engine')
-
-measures_dir = ENV['MEASURE_DIR'] || 'measures'
-bundle_dir = ENV['BUNDLE_DIR'] || '.'
-fixtures_dir = ENV['FIXTURE_DIR'] || File.join('fixtures', 'measures')
-db_name = ENV['DB_NAME'] || 'test'
-loader = QME::Database::Loader.new()
-
-namespace :mongo do
-
-  desc 'Removed cached measure results'
-  task :drop_cache do
-    loader.drop_collection('query_cache')
-    loader.drop_collection('patient_cache')
-  end
-  
-  desc 'Remove the patient records collection'
-  task :drop_records => :drop_cache do
-    loader.drop_collection('records')
-  end
-
-  desc 'Remove the measures and bundles collection'
-  task :drop_bundle do
-    loader.drop_collection('bundles')
-    loader.drop_collection('measures')
-  end
-  
-  desc 'Remove all patient records and reload'
-  task :reload_records => :drop_records do
-    load_files(loader, File.join(fixtures_dir,'*','patients','*.json'), 'records')
-  end
-
-  desc 'Remove all patient records and reload'
-  task :reload_bundle => [:drop_bundle] do
-   loader.save_bundle(bundle_dir, measures_dir)
-  end
-  
-  desc 'Clear database and road each measure and its sample patient files'
-  task :reload => [:reload_records, :reload_bundle]
-  
-  desc 'Seed the query cache by calculating the results for all measures'
-  task :seed_cache, [:year, :month, :day] do |t, args|
-    db = loader.get_db
-    patient_cache = db['patient_cache']
-    patient_cache.create_index([['value.measure_id', Mongo::ASCENDING],
-                                ['value.sub_id', Mongo::ASCENDING],
-                                ['value.effective_date', Mongo::ASCENDING]])
-    year = args.year.to_i>0 ? args.year.to_i : 2010
-    month = args.month.to_i>0 ? args.month.to_i : 9
-    day = args.day.to_i>0 ? args.day.to_i : 19
-    QME::QualityMeasure.all.each_value do |measure_def|
-      QME::MapReduce::MeasureCalculationJob.create(:measure_id => measure_def['id'], :sub_id => measure_def['sub_id'], :effective_date => Time.gm(year, month, day).to_i)
-    end
-  end
-  
-  def load_files(loader, file_pattern, collection_name)
-    Dir.glob(file_pattern).each do |file|
-      json = JSON.parse(File.read(file))
-      loader.save(collection_name, json)
-    end
-  end
-  
-end

data/lib/tasks/patient_random.rake

@@ -1,45 +0,0 @@
-path = File.dirname(__FILE__)
-path = path.index('lib') == 0 ? "./#{path}" : path
-require 'mongo'
-require 'json'
-require File.join(path,'../quality-measure-engine')
-
-patient_template_dir = ENV['PATIENT_TEMPLATE_DIR'] || File.join('fixtures', 'patient_templates')
-db_name = ENV['DB_NAME'] || 'test'
-loader = QME::Database::Loader.new(db_name)
-
-namespace :patient do
-
-  desc 'Generate n (default 10) random patient records and save them in the database'
-  task :random, [:n] => ['mongo:drop_records'] do |t, args|
-    n = args.n.to_i>0 ? args.n.to_i : 10
-    
-    templates = []
-    Dir.glob(File.join(patient_template_dir, '*.json.erb')).each do |file|
-      templates << File.read(file)
-    end
-    
-    if templates.length<1
-      puts "No patient templates in #{patient_template_dir}"
-      return
-    end
-    
-    processed_measures = {}
-    QME::QualityMeasure.all.each_value do |measure_def|
-      measure_id = measure_def['id']
-      if !processed_measures[measure_id]
-        QME::Importer::MeasurePropertiesGenerator.instance.add_measure(measure_id, QME::Importer::GenericImporter.new(measure_def))
-        processed_measures[measure_id]=true
-      end
-    end
-
-    n.times do
-      template = templates[rand(templates.length)]
-      generator = QME::Randomizer::Patient.new(template)
-      json = JSON.parse(generator.get())
-      patient_record = QME::Randomizer::RandomPatientCreator.parse_hash(json)
-      patient_record.save!
-    end
-  end
-    
-end

data/spec/qme/bundle_spec.rb

@@ -1,37 +0,0 @@
-describe QME::MapReduce::Executor do
-
-  before :all do
-    @bundle_dir = File.join(File.dirname(__FILE__),'../../fixtures/bundle')
-    @measure_dir = 'measures'
-  end
-
-  before do
-    @loader = QME::Database::Loader.new('test')
-    @loader.get_db.drop_collection('measures')
-    @loader.get_db.drop_collection('bundles')
-  end
-  
-  it 'Should be able to load a bundle' do
-    bundle = @loader.save_bundle(@bundle_dir, @measure_dir)
-    bundle[:measures].length.should == 1
-    bundle[:bundle_data][:extensions].length.should == 3
-    bundle[:bundle_data]['name'].should == "test_bundle"
-    @loader.get_db['bundles'].count.should == 1
-    @loader.get_db['bundles'].find_one['name'].should == 'test_bundle'
-  end
-  
-  
-  it 'should be able to remove a bundle' do 
-    bundle = @loader.save_bundle(@bundle_dir, @measure_dir)
-    bundle_measures_count = bundle[:measures].length
-    @loader.get_db['bundles'].count.should == 1
-    measures = @loader.get_db['measures'].count
-    
-    @loader.remove_bundle(bundle[:bundle_data]['_id'])
-    @loader.get_db['bundles'].count.should == 0
-    measures = @loader.get_db['measures'].count.should == (measures - bundle_measures_count)
-    
-    
-  end
-  
- end

data/spec/qme/importer/generic_importer_spec.rb

@@ -1,73 +0,0 @@
-describe QME::Importer::GenericImporter do
-
-  it "should properly handle devices" do
-    measure_def = {'measure' => {"cardiac_pacer" => {
-      "standard_category" => "device",
-      "qds_data_type" => "device_applied",
-      "type" => "array",
-      "items" => {
-        "type" => "number",
-        "format" => "utc-sec"
-      },
-      "codes" => [
-        {
-          "set" => "SNOMED-CT",
-          "values" => [
-            "14106009",
-            "56961003"
-          ]
-        }
-      ]
-    }}}
-    
-    entry = Entry.new
-    entry.add_code('14106009', 'SNOMED-CT')
-    entry.start_time = 1026777600
-    
-    patient = Record.new
-    patient.medical_equipment = [entry]
-    
-    gi = QME::Importer::GenericImporter.new(measure_def)
-    measure_info = gi.parse(patient)
-    measure_info['cardiac_pacer'].should include(1026777600)
-  end
-  
-  it "should handle active conditions" do
-    measure_def = {'measure' => {"silliness" => {
-      "standard_category" => "diagnosis_condition_problem",
-      "qds_data_type" => "diagnosis_active",
-      "type" => "array",
-      "items" => {
-        "type" => "number",
-        "format" => "utc-sec"
-      },
-      "codes" => [
-        {
-          "set" => "SNOMED-CT",
-          "values" => [
-            "14106009",
-            "56961003"
-          ]
-        }
-      ]
-    }}}
-    
-    entry1 = Entry.new
-    entry1.add_code('14106009', 'SNOMED-CT')
-    entry1.start_time = 1026777600
-    entry1.status = 'active'
-    
-    entry2 = Entry.new
-    entry2.add_code('14106009', 'SNOMED-CT')
-    entry2.start_time = 1026777601
-    entry2.status = 'inactive'
-    
-    patient = Record.new
-    patient.conditions = [entry1, entry2]
-    
-    gi = QME::Importer::GenericImporter.new(measure_def)
-    measure_info = gi.parse(patient)
-    measure_info['silliness'].should include(1026777600)
-    measure_info['silliness'].should_not include(1026777601)
-  end
-end

data/spec/qme/importer/measure_properties_generator_spec.rb

@@ -1,15 +0,0 @@
-describe QME::Importer::MeasurePropertiesGenerator do
-  it 'should generate measure properties' do
-      doc = Nokogiri::XML(File.new('fixtures/c32_fragments/0032/numerator.xml'))
-      doc.root.add_namespace_definition('cda', 'urn:hl7-org:v3')
-
-      measure_json = JSON.parse(File.read(File.join('fixtures', 'entry', 'sample.json')))
-      QME::Importer::MeasurePropertiesGenerator.instance.add_measure('0043', QME::Importer::GenericImporter.new(measure_json))
-
-      patient = HealthDataStandards::Import::C32::PatientImporter.instance.parse_c32(doc)
-
-      measure_properties = QME::Importer::MeasurePropertiesGenerator.instance.generate_properties(patient)
-
-      measure_properties['0043']['encounter'].should include(1270598400)
-  end
-end

data/spec/qme/importer/property_matcher_spec.rb

@@ -1,174 +0,0 @@
-describe QME::Importer::PropertyMatcher do
-  
-  it "should raise an error when it can't determine the property schema" do
-    property_description = {
-      "type" => "cheese",
-      "description"  => "A cheesey example"
-    }
-    
-    pm = QME::Importer::PropertyMatcher.new(property_description)
-    expect {pm.match([])}.to raise_error
-  end
-  
-  it "should be able to extract a date list property" do
-    property_description = {
-      "type" => "array",
-      "items" =>  {
-        "type" => "number"
-      },
-      "codes" =>  [
-        {
-          "set" => "SNOMED-CT",
-          "values" => ["314443004"]
-        }
-      ]
-    }
-    
-    pm = QME::Importer::PropertyMatcher.new(property_description)
-    
-    entry = Entry.new
-    entry.add_code('314443004', 'SNOMED-CT')
-    entry.start_time = 1026777600
-    
-    result = pm.match([entry])
-    result.should include(1026777600)
-  end
-  
-
-  describe 'when extracting a date/value list property' do
-    it "should be able to deal with number values" do
-      property_description = {
-        "type" => "array",
-        "items" => {
-          "type" => "object",
-          "properties" => {
-            "value" => {
-              "type" => "number"
-            },
-            "date" =>  {
-              "type" => "number"
-            }
-          }
-        },
-        "codes" =>  [
-          {
-            "set" => "SNOMED-CT",
-            "values" => ["314443004"]
-          }
-        ]
-      }
-
-      pm = QME::Importer::PropertyMatcher.new(property_description)
-
-      entry = Entry.new
-      entry.add_code('314443004', 'SNOMED-CT')
-      entry.set_value('11.45')
-      entry.start_time = 1026777600
-
-      result = pm.match([entry])
-      result.should include({'date' => 1026777600, 'value' => 11.45})
-      result.length.should == 1
-    end
-    
-    it "should be able to deal with boolean values" do
-      property_description = {
-        "type" => "array",
-        "items" => {
-          "type" => "object",
-          "properties" => {
-            "value" => {
-              "type" => "boolean"
-            },
-            "date" =>  {
-              "type" => "number"
-            }
-          }
-        },
-        "codes" =>  [
-          {
-            "set" => "SNOMED-CT",
-            "values" => ["314443004"]
-          }
-        ]
-      }
-
-      pm = QME::Importer::PropertyMatcher.new(property_description)
-
-      entry = Entry.new
-      entry.add_code('314443004', 'SNOMED-CT')
-      entry.set_value('true')
-      entry.start_time = 1026777600
-
-      result = pm.match([entry])
-      result.should include({'date' => 1026777600, 'value' => true})
-      result.length.should == 1
-    end
-    
-    it "should be able to deal with string" do
-      property_description = {
-        "type" => "array",
-        "items" => {
-          "type" => "object",
-          "properties" => {
-            "value" => {
-              "type" => "string"
-            },
-            "date" =>  {
-              "type" => "number"
-            }
-          }
-        },
-        "codes" =>  [
-          {
-            "set" => "SNOMED-CT",
-            "values" => ["314443004"]
-          }
-        ]
-      }
-
-      pm = QME::Importer::PropertyMatcher.new(property_description)
-
-      entry = Entry.new
-      entry.add_code('314443004', 'SNOMED-CT')
-      entry.set_value('super critical')
-      entry.start_time = 1026777600
-
-      result = pm.match([entry])
-      result.should include({'date' => 1026777600, 'value' => 'super critical'})
-      result.length.should == 1
-    end
-  end
-
-  it "should be able to extract a date range property" do
-    property_description = {
-      "type" => "array",
-      "items" => {
-        "type" => "object",
-        "properties" => {
-          "start" => {
-            "type" => "number"
-          },
-          "end" =>  {
-            "type" => "number"
-          }
-        }
-      },
-      "codes" =>  [
-        {
-          "set" => "SNOMED-CT",
-          "values" => ["194774006"]
-        }
-      ]
-    }
-    
-    pm = QME::Importer::PropertyMatcher.new(property_description)
-
-    entry = Entry.new
-    entry.add_code('194774006', 'SNOMED-CT')
-    entry.start_time = 1026777600
-    entry.end_time = 1189814400
-    
-    result = pm.match([entry])
-    result.should include({'start' => 1026777600, 'end' => 1189814400})
-  end
-end