health-data-standards 3.0.6 → 3.1.0

data/README.md

@@ -1,4 +1,6 @@
-This is a project to generate and consume HITSP C32, ASTM CCR and PQRI
+This is a project to generate and consume HITSP C32, ASTM CCR, QRDA Category I and PQRI.
+
+In addition this project also contains libaries for parsing hqmf documents and for dealing with NLM valuesets.
 
 Environment
 ===========

data/Rakefile

@@ -2,6 +2,8 @@ require 'rake/testtask'
 require 'cane/rake_task'
 require "simplecov"
 
+import 'lib/tasks/hqmf.rake'
+
 Rake::TestTask.new(:test_unit) do |t|
   t.libs << "test"
   t.test_files = FileList['test/**/*_test.rb']

data/lib/health-data-standards.rb

@@ -7,6 +7,7 @@ require 'csv'
 require 'nokogiri'
 require 'ostruct'
 require 'log4r'
+require 'memoist'
 
 # Freedom patches
 require_relative 'health-data-standards/ext/symbol'
@@ -40,6 +41,7 @@ require_relative 'health-data-standards/models/thing_with_codes'
 require_relative 'health-data-standards/models/result_value'
 require_relative 'health-data-standards/models/coded_result_value'
 require_relative 'health-data-standards/models/physical_quantity_result_value'
+require_relative 'health-data-standards/models/cda_identifier'
 require_relative 'health-data-standards/models/entry'
 require_relative 'health-data-standards/models/allergy'
 require_relative 'health-data-standards/models/encounter'
@@ -76,6 +78,7 @@ require_relative 'health-data-standards/models/metadata/pedigree'
 require_relative 'health-data-standards/export/qrda/entry_template_resolver'
 require_relative 'health-data-standards/export/helper/cat1_view_helper'
 require_relative 'health-data-standards/export/cat_1'
+require_relative 'health-data-standards/export/cat_3'
 
 require_relative 'health-data-standards/import/cda/narrative_reference_handler'
 require_relative 'health-data-standards/import/cda/entry_finder'
@@ -135,17 +138,24 @@ require_relative 'health-data-standards/import/green_c32/care_goal_importer'
 
 require_relative 'health-data-standards/import/cat1/gestational_age_importer'
 require_relative 'health-data-standards/import/cat1/procedure_intolerance_importer'
+require_relative 'health-data-standards/import/cat1/procedure_performed_importer'
 require_relative 'health-data-standards/import/cat1/procedure_order_importer'
 require_relative 'health-data-standards/import/cat1/diagnosis_active_importer'
 require_relative 'health-data-standards/import/cat1/diagnosis_inactive_importer'
 require_relative 'health-data-standards/import/cat1/patient_importer'
 require_relative 'health-data-standards/import/cat1/lab_order_importer'
+require_relative 'health-data-standards/import/cat1/medication_active_importer'
 require_relative 'health-data-standards/import/cat1/medication_dispensed_importer'
 require_relative 'health-data-standards/import/cat1/encounter_order_importer'
 require_relative 'health-data-standards/import/cat1/diagnostic_study_order_importer'
 require_relative 'health-data-standards/import/cat1/tobacco_use_importer'
 require_relative 'health-data-standards/import/cat1/entry_package'
+require_relative 'health-data-standards/import/cat1/lab_result_importer'
+require_relative 'health-data-standards/import/cat1/ecog_status_importer'
+require_relative 'health-data-standards/import/cat1/symptom_active_importer'
 
+require_relative 'health-data-standards/models/cqm/aggregate_objects'
+require_relative 'health-data-standards/models/cqm/query_cache'
 require_relative 'health-data-standards/models/cqm/bundle'
 require_relative 'health-data-standards/models/cqm/measure'
 require_relative 'health-data-standards/import/bundle/importer'

data/lib/health-data-standards/export/cat_3.rb

@@ -0,0 +1,24 @@
+module HealthDataStandards
+  module Export
+    class Cat3
+      def initialize
+        template_helper = HealthDataStandards::Export::TemplateHelper.new('cat3', 'cat3')
+        @rendering_context = HealthDataStandards::Export::RenderingContext.new
+        @rendering_context.template_helper = template_helper
+        @cat1_renderer = HealthDataStandards::Export::RenderingContext.new
+        @cat1_renderer.template_helper = HealthDataStandards::Export::TemplateHelper.new('cat1', 'cat1')
+      end
+
+      def export(measures, effective_date, start_date, end_date, test_id=nil)
+        results = {}
+        measures.each do |measure|
+          results[measure['hqmf_id']] = HealthDataStandards::CQM::QueryCache.aggregate_measure(measure['hqmf_id'], effective_date, test_id)
+        end
+        @rendering_context.render(:template => 'show', 
+                                  :locals => {:measures => measures, :start_date => start_date, 
+                                              :end_date => end_date, :cat1_renderer => @cat1_renderer,
+                                              :results => results})
+      end
+    end
+  end
+end

data/lib/health-data-standards/export/html.rb

@@ -6,10 +6,11 @@ module HealthDataStandards
         @rendering_context = RenderingContext.new
         @rendering_context.template_helper = template_helper
         @rendering_context.extensions = [HealthDataStandards::Export::Helper::HTMLViewHelper]
-        @code_map ||= self.build_code_map
+        @code_map = nil
       end
 
       def export(patient)
+        @code_map ||= self.build_code_map
         @rendering_context.render(:template => 'show', :locals => {:patient => patient, :code_map => @code_map})
       end
       

data/lib/health-data-standards/import/bundle/importer.rb

@@ -1,148 +1,180 @@
+require 'zip/zipfilesystem'
 module HealthDataStandards
-	module Import
-		module Bundle
-			
-			class Importer
-			COLLECTION_NAMES = ["bundles", "records", "measures", "selected_measures", "patient_cache", "query_cache", "system.js"]
-			DEFAULTS = {clear_db: false, 
-									type: nil,
-							    delete_existing: false,
-								  update_measures: true,
-								  clear_collections: COLLECTION_NAMES
-								}
-			# Import a quality bundle into the database. This includes metadata, measures, test patients, supporting JS libraries, and expected results.
-		  #
-		  # @param [File] zip The bundle zip file.
-		  # @param [String] Type of measures to import, either 'ep', 'eh' or nil for all
-		  # @param [Boolean] keep_existing If true, delete all current collections related to patients and measures.
-		  def self.import(zip,  options={})
-		    options = DEFAULTS.merge(options)
-		    bundle_versions = Hash[* HealthDataStandards::CQM::Bundle.where({}).collect{|b| [b._id, b.version]}.flatten]
-		    # Unpack content from the bundle.
-		    bundle_contents = unpack_bundle_contents(zip, options[:type])
-		    bundle =  HealthDataStandards::CQM::Bundle.new( JSON.parse(bundle_contents[:bundle]))
-		    
-		    if bundle_versions.invert[bundle.version]  && !(options[:delete_existing] || options[:clear_db])
-		      raise "A bundle with version #{bundle.version} already exists in the database. "
-		    end
-
-		    drop_collections(COLLECTION_NAMES+(options[:clear_collections]||[])) if options[:clear_db]
-		     HealthDataStandards::CQM::Bundle.where({:version => bundle.version}).each {|b| b.delete}
-		    # Store all JS libraries.
-		    bundle_contents[:extensions].each do |key, contents|
-		      save_system_js_fn(key, contents)
-		    end
-
-		    # Store the bundle metadata.
-
-		    
-		    unless bundle.save
-		    	raise bundle.errors.full_messages.join(",")
-		    end
-
-		    bundle_id = bundle.id
-		    
-		    
-		    # Store all measures.
-		    bundle_contents[:measures].each do |key, contents|
-		      json = JSON.parse(contents, {:max_nesting => 100})
-		      measure = json.clone
-		      # measure =  HealthDataStandards::CQM::Measure.new(json)
-		      measure['bundle_id'] = bundle_id
-		      Mongoid.default_session["measures"].insert(measure)
-	
-
-		      if options[:update_measures]
-		      	  Mongoid.default_session["measures"].where({hqmf_id: measure["hqmf_id"], sub_id: measure["sub_id"]}).each do |m|
-		      		b = HealthDataStandards::CQM::Bundle.find(m["bundle_id"])
-		      		if b.version < bundle.version
-		      			m.merge!(json)
-		      			Mongoid.default_session["measures"].where({"_id" => m["_id"]}).update(m)
-		      		end
-
-		      	end
-		      end
-		    end
-		    
-		 
-		    bundle_contents[:patients].each do |key, contents|
-		      patient = Record.new( JSON.parse(contents, {:max_nesting => 100}))
-		      patient['bundle_id'] = bundle_id
-		      patient.save
-		    end
-
-		    bundle_contents[:valuesets].each do |key, contents|
-		      json = JSON.parse(contents, {:max_nesting => 100})
-		      vs = HealthDataStandards::SVS::ValueSet.new(json)
-		      vs['bundle_id'] = bundle_id
-		      vs.save
-		    end
-		    
-		    # Store the expected results into the query and patient caches.
-		    bundle_contents[:results].each do |name, contents|
-		      collection = name == "by_patient" ? "patient_cache" : "query_cache"
-		      contents = JSON.parse(contents, {:max_nesting => 100})
-
-		      contents.each {|document| 
-		        document['bundle_id'] = bundle_id
-		        Mongoid.default_session[collection].insert(document)
-		      }
-
-		    end
-		    
-		    bundle
-		  end
-
-		# Delete a list of collections. By default, this function drops all of collections related to measures and patients.
-    #
-    # @param [Array] collection_names Optionally, an array of collection names to be dropped.
-    def self.drop_collections(collection_names=[])
-      collection_names = COLLECTION_NAMES if collection_names.empty?
-      collection_names.each {|collection| Mongoid.default_session[collection].drop}
-    end  
-
-		# Save a javascript function into Mongo's system.js collection for measure execution.
-		#
-		# @param [String] name The name by which the function will be referred.
-		# @param [String] fn The body of the function being saved.
-		def self.save_system_js_fn(name, fn)
-		  fn = "function () {\n #{fn} \n }"
-		  Mongoid.default_session['system.js'].find('_id' => name).upsert(
-		    {
-		      "_id" => name,
-		      "value" => Moped::BSON::Code.new(fn)
-		    }
-		  )
-		end
-
-		# A utility function for finding files in a bundle. Strip a file path of it's extension and just give the filename.
-		#
-		# @param [String] original A file path.
-		# @param [String] extension A file extension.
-		# @return The filename at the end of the original String path with the extension removed. e.g. "/boo/urns.html" -> "urns"
-		def self.entry_key(original, extension)
-		  original.split('/').last.gsub(".#{extension}", '')
-		end
-
-		def self.unpack_bundle_contents(zip, type = nil)
-		  bundle_contents = { bundle: nil, measures: {}, patients: {}, extensions: {}, results: {}, valuesets: {} }
-		  Zip::ZipFile.open(zip.path) do |zipfile|
-		    zipfile.entries.each do |entry|
-		      bundle_contents[:bundle] = zipfile.read(entry.name) if entry.name.include? "bundle"
-		      if type.nil? || entry.name.match(Regexp.new("/#{type}/")) 
-		        bundle_contents[:measures][entry_key(entry.name, "json")] = zipfile.read(entry.name) if entry.name.match /^measures.*\.json$/
-		        bundle_contents[:patients][entry_key(entry.name, "json")] = zipfile.read(entry.name) if entry.name.match /^patients.*\.json$/ # Only need to import one of the formats
-		        bundle_contents[:results][entry_key(entry.name,"json")] = zipfile.read(entry.name) if entry.name.match /^results.*\.json/
-		      end
-		      bundle_contents[:extensions][entry_key(entry.name,"js")] = zipfile.read(entry.name) if entry.name.match /^library_functions.*\.js/
-
-		      bundle_contents[:valuesets][entry_key(entry.name,"json")] = zipfile.read(entry.name) if entry.name.match /^value_sets.*\.json/
-		    end
-		  end
-		  bundle_contents
-			end
-		end
-
-		end
-	end
+  module Import
+    module Bundle
+      
+      class Importer
+
+        SOURCE_ROOTS = {bundle: 'bundle.json', 
+                        libraries: File.join('library_functions','*.js'), 
+                        measures: 'measures', results: 'results', 
+                        valuesets: File.join('value_sets','json','*.json'), 
+                        patients: 'patients'}
+        COLLECTION_NAMES = ["bundles", "records", "measures", "selected_measures", "patient_cache", "query_cache", "system.js"]
+        CLEAR_ONLY_COLLECTIONS = ["system.js"]
+        DEFAULTS = {type: nil,
+                    delete_existing: false,
+                    update_measures: true,
+                    clear_collections: COLLECTION_NAMES
+                  }
+
+        # Import a quality bundle into the database. This includes metadata, measures, test patients, supporting JS libraries, and expected results.
+        #
+        # @param [File] zip The bundle zip file.
+        # @param [String] Type of measures to import, either 'ep', 'eh' or nil for all
+        # @param [Boolean] keep_existing If true, delete all current collections related to patients and measures.
+        def self.import(zip,  options={})
+          options = DEFAULTS.merge(options)
+
+          bundle = nil
+          Zip::ZipFile.open(zip.path) do |zip_file|
+
+            bundle = unpack_bundle(zip_file)
+
+            bundle_versions = Hash[* HealthDataStandards::CQM::Bundle.where({}).collect{|b| [b._id, b.version]}.flatten]
+            if bundle_versions.invert[bundle.version] && !(options[:delete_existing])
+              raise "A bundle with version #{bundle.version} already exists in the database. "
+            end
+
+            HealthDataStandards::CQM::Bundle.where({:version => bundle.version}).each do |b| 
+              puts "deleting existing bundle version: #{b.version}"
+              b.delete
+            end if options[:delete_existing]
+
+            unpack_and_store_system_js(zip_file)
+
+            # Store the bundle metadata.
+            unless bundle.save
+              raise bundle.errors.full_messages.join(",")
+            end
+            puts "bundle metadata unpacked..."
+
+            measure_ids = unpack_and_store_measures(zip_file, options[:type], bundle, options[:update_measures])
+            unpack_and_store_patients(zip_file, options[:type], bundle)
+            unpack_and_store_valuesets(zip_file, bundle)
+            unpack_and_store_results(zip_file, options[:type], measure_ids, bundle)
+
+          end
+
+          bundle
+        end
+
+
+        # Save a javascript function into Mongo's system.js collection for measure execution.
+        #
+        # @param [String] name The name by which the function will be referred.
+        # @param [String] fn The body of the function being saved.
+        def self.save_system_js_fn(name, fn)
+          fn = "function () {\n #{fn} \n }"
+          Mongoid.default_session['system.js'].find('_id' => name).upsert(
+            {
+              "_id" => name,
+              "value" => Moped::BSON::Code.new(fn)
+            }
+          )
+        end
+
+        # A utility function for finding files in a bundle. Strip a file path of it's extension and just give the filename.
+        #
+        # @param [String] original A file path.
+        # @param [String] extension A file extension.
+        # @return The filename at the end of the original String path with the extension removed. e.g. "/boo/urns.html" -> "urns"
+        def self.entry_key(original, extension)
+          original.split('/').last.gsub(".#{extension}", '')
+        end
+
+        def self.unpack_bundle(zip)
+          HealthDataStandards::CQM::Bundle.new(JSON.parse(zip.read(SOURCE_ROOTS[:bundle]),max_nesting: 100))
+        end
+
+        def self.unpack_and_store_system_js(zip)
+          zip.glob(SOURCE_ROOTS[:libraries]).each do |entry|
+            name = Pathname.new(entry.name).basename('.js').to_s
+            contents = entry.get_input_stream.read
+            save_system_js_fn(name, contents)
+          end
+        end
+
+        def self.unpack_and_store_measures(zip, type, bundle, update_measures)
+          measure_ids = []
+          entries = zip.glob(File.join(SOURCE_ROOTS[:measures],type || '**','*.json'))
+          entries.each_with_index do |entry, index|
+            source_measure = unpack_json(entry)
+            # we clone so that we have a source without a bundle id
+            measure = source_measure.clone
+            measure_ids << measure['id']
+            measure['bundle_id'] = bundle.id
+            Mongoid.default_session["measures"].insert(measure)
+
+            if update_measures
+              Mongoid.default_session["measures"].where({hqmf_id: measure["hqmf_id"], sub_id: measure["sub_id"]}).each do |m|
+                b = HealthDataStandards::CQM::Bundle.find(m["bundle_id"])
+                if b.version < bundle.version
+                  m.merge!(source_measure)
+                  Mongoid.default_session["measures"].where({"_id" => m["_id"]}).update(m)
+                end
+              end
+            end
+            report_progress('measures', (index*100/entries.length)) if index%10 == 0
+          end
+          puts "\rLoading: Measures Complete          "
+          measure_ids
+        end
+
+        def self.unpack_and_store_patients(zip, type, bundle)
+          entries = zip.glob(File.join(SOURCE_ROOTS[:patients],type || '**','json','*.json'))
+          entries.each_with_index do |entry, index|
+            patient = Record.new(unpack_json(entry))
+            patient['bundle_id'] = bundle.id
+            patient.save
+            report_progress('patients', (index*100/entries.length)) if index%10 == 0
+          end
+          puts "\rLoading: Patients Complete          "
+        end
+
+        def self.unpack_and_store_valuesets(zip, bundle)
+          entries = zip.glob(SOURCE_ROOTS[:valuesets])
+          bulk = []
+          entries.each_with_index do |entry, index|
+            vs = HealthDataStandards::SVS::ValueSet.new(unpack_json(entry))
+            vs['bundle_id'] = bundle.id
+            bulk << vs
+            report_progress('Value Sets', (index*100/entries.length)) if index%10 == 0
+          end
+          HealthDataStandards::SVS::ValueSet.collection.insert(bulk.map {|vs| vs.as_document})
+          puts "\rLoading: Value Sets Complete          "
+        end
+
+        def self.unpack_and_store_results(zip, type, measure_ids, bundle)
+          zip.glob(File.join(SOURCE_ROOTS[:results],'*.json')).each do |entry|
+            name = Pathname.new(entry.name).basename('.json').to_s
+            collection = (name == "by_patient") ? "patient_cache" : "query_cache"
+
+            contents = unpack_json(entry)
+
+            if (type)
+              contents.select! {|entry| measure_ids.include? entry['measure_id']} if collection == 'query_cache'
+              contents.select! {|entry| measure_ids.include? entry['value']['measure_id']} if collection == 'patient_cache'
+            end
+
+            contents.each do |document| 
+              document['bundle_id'] = bundle.id
+              Mongoid.default_session[collection].insert(document)
+            end
+          end
+          puts "\rLoading: Results Complete          "
+        end
+
+        def self.unpack_json(entry)
+          JSON.parse(entry.get_input_stream.read,:max_nesting => 100)
+        end
+
+        def self.report_progress(label, percent)
+          print "\rLoading: #{label} #{percent}% complete"
+          STDOUT.flush
+        end
+
+      end
+    end
+  end
 end

data/lib/health-data-standards/import/cat1/diagnosis_active_importer.rb

@@ -8,11 +8,6 @@ module HealthDataStandards
           @status_xpath = nil # We'll hardcode this to active in create entry because this is from the 
                               # diagnosis active template
         end
-
-        def create_entry(entry_element, nrh = CDA::NarrativeReferenceHandler.new)
-          condition = super
-          condition
-        end
       end
     end
   end

data/lib/health-data-standards/import/cat1/diagnosis_inactive_importer.rb

@@ -5,14 +5,9 @@ module HealthDataStandards
 
         def initialize
           super(CDA::EntryFinder.new("//cda:observation[cda:templateId/@root='2.16.840.1.113883.10.20.24.3.13']"))
-          @status_xpath = nil # We'll hardcode this to active in create entry because this is from the 
+          @status_xpath = nil # We'll hardcode this to inactive in create entry because this is from the 
                               # diagnosis active template
         end
-
-        def create_entry(entry_element, nrh = CDA::NarrativeReferenceHandler.new)
-          condition = super
-          condition
-        end
       end
     end
   end