health-data-standards 2.2.1 → 3.0.3

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

@@ -1,14 +1,48 @@
-require 'ostruct'
-
 module HealthDataStandards
   module Export
+    # Used to actually render stuff. A RenderingContext needs to be set up with
+    # a template helper and may be provided with extensions.
+    #
+    # :call-seq:
+    #   template_helper = HealthDataStandards::Export::TemplateHelper.new('cat1', 'cat1')
+    #   rendering_context = HealthDataStandards::Export::RenderingContext.new
+    #   rendering_context.template_helper = template_helper
+    #   rendering_context.extensions = [HealthDataStandards::Export::Helper::Cat1ViewHelper]
+    #
+    # In this case, a RenderingContext is being set up to generate Category 1 files. It is
+    # passed a template helper to finds the correct ERb templates to render from. It is also
+    # given an extension. This is just a Ruby Module which will have its methods exposed to
+    # the templates. RenderingContext will assume that extensions is an Array and will include
+    # multiple extensions if more than one is provided.  
     class RenderingContext < OpenStruct
-      include TemplateHelper
       include ViewHelper
+      attr_accessor :template_helper, :extensions
 
       def my_binding
         binding
       end
+
+      def render(params)
+        erb = nil
+        if params[:template]
+          erb = @template_helper.template(params[:template])
+        elsif params[:partial]
+          erb = @template_helper.partial(params[:partial])
+        end
+        
+        locals = params[:locals]
+        locals ||= {}
+        rendering_context = RenderingContext.new(locals)
+        rendering_context.template_helper = @template_helper
+        if @extensions.present?
+          rendering_context.extensions = @extensions
+          @extensions.each do |extension|
+            rendering_context.extend(extension)
+          end
+        end
+        eruby = Erubis::EscapedEruby.new(erb) # TODO: cache these
+        eruby.result(rendering_context.my_binding)
+      end
     end
   end
 end

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

@@ -1,9 +1,20 @@
 module HealthDataStandards
   module Export
-    module TemplateHelper
-      attr_accessor :template_format
-      attr_accessor :template_subdir
-      attr_accessor :template_directory
+    # Class that finds ERb templates. Here is how it can be configured:
+    # [template_format] What format (C32, CCDA, etc) are we looking for. This will cause
+    #                   the TemplateHelper to look for template_name.template_format.erb
+    # [template_subdir] The sub directory where templates live. If none is provided, it
+    #                   will look for templates in the root of the template_directory
+    # [template_directory] The root directory to look in for templates. By default, it
+    #                      is in the template folder of this gem. It can be handy to
+    #                      provide a different directory if you want to use this class
+    #                      outside of the HDS gem
+    class TemplateHelper
+      def initialize(template_format, template_subdir = nil, template_directory = nil)
+        @template_format = template_format
+        @template_directory = template_directory
+        @template_subdir = template_subdir
+      end
 
       def template_root
         @template_directory ||= File.dirname(__FILE__)
@@ -15,31 +26,17 @@ module HealthDataStandards
         end
       end
 
+      # Returns the raw ERb for the template_name provided. This method will look in
+      # template_directory/template_subdir/template_name.template_format.erb
       def template(template_name)
-        File.read(File.join(template_root, "#{template_name}.#{self.template_format}.erb"))
+        File.read(File.join(template_root, "#{template_name}.#{@template_format}.erb"))
       end
 
+      # Basically the same template, but prepends an underscore to the template name
+      # to mimic the Rails convention for template fragments
       def partial(partial_name)
         template("_#{partial_name}")
       end
-
-      def render(params)
-        erb = nil
-        if params[:template]
-          erb = template(params[:template])
-        elsif params[:partial]
-          erb = partial(params[:partial])
-        end
-        
-        locals = params[:locals]
-        locals ||= {}
-        rendering_context = RenderingContext.new(locals)
-        rendering_context.template_format = self.template_format
-        rendering_context.template_subdir = self.template_subdir
-        rendering_context.template_directory = self.template_directory
-        eruby = Erubis::EscapedEruby.new(erb)
-        eruby.result(rendering_context.my_binding)
-      end
     end
   end
 end

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

@@ -4,18 +4,22 @@ module HealthDataStandards
       def code_display(entry, options={})
         options['tag_name'] ||= 'code'
         options['attribute'] ||= :codes
+        options['exclude_null_flavor'] ||= false
         code_string = nil
         preferred_code = entry.preferred_code(options['preferred_code_sets'], options['attribute'])
         if preferred_code
           code_system_oid = HealthDataStandards::Util::CodeSystemHelper.oid_for_code_system(preferred_code['code_set'])
           code_string = "<#{options['tag_name']} code=\"#{preferred_code['code']}\" codeSystem=\"#{code_system_oid}\" #{options['extra_content']}>"
         else
-          code_string = "<#{options['tag_name']} nullFlavor=\"UNK\" #{options['extra_content']}>"
+          code_string = "<#{options['tag_name']} "
+          code_string += "nullFlavor=\"UNK\" " unless options["exclude_null_flavor"]
+          code_string += "#{options['extra_content']}>"
         end
         
-        code_string += "<originalText>#{ERB::Util.html_escape entry.description}</originalText>" if entry.respond_to?(:description)
         
-        if entry.respond_to?(:translation_codes)
+        
+        if options["attribute"] == :codes && entry.respond_to?(:translation_codes)
+          code_string += "<originalText>#{ERB::Util.html_escape entry.description}</originalText>" if entry.respond_to?(:description)
           entry.translation_codes(options['preferred_code_sets']).each do |translation|
             code_string += "<translation code=\"#{translation['code']}\" codeSystem=\"#{HealthDataStandards::Util::CodeSystemHelper.oid_for_code_system(translation['code_set'])}\"/>\n"
           end
@@ -24,20 +28,7 @@ module HealthDataStandards
         code_string += "</#{options['tag_name']}>"
         code_string
       end
-      
-      def gc32_effective_time(entry)
-        if entry.time
-          "<effectiveTime value=\"#{Time.at(entry.time).to_formatted_s(:number)}\" />"
-        elsif entry.start_time || entry.end_time
-          time = "<effectiveTime>"
-          time += "<start value=\"#{Time.at(entry.start_time).to_formatted_s(:number)}\" />"  if entry.start_time
-          time += "<end value=\"#{Time.at(entry.end_time).to_formatted_s(:number)}\" />" if entry.end_time
-          time += "</effectiveTime>"
-        else
-          "<effectiveTime />"
-        end
-      end
-      
+            
       def status_code_for(entry)
         case entry.status.to_s.downcase
         when 'active'
@@ -58,16 +49,6 @@ module HealthDataStandards
        end
       end
 
-      
-      def quantity_display(value, tag_name="value")
-        return unless value
-        if value.respond_to?(:scalar)
-          "<#{tag_name} value=\"#{value.scalar}\" units=\"#{value.units}\" />"
-        else
-          "<#{tag_name} value=\"#{value['value']}\" units=\"#{value['unit']}\" />"
-        end
-      end
-
       def time_if_not_nil(*args)
         args.compact.map {|t| Time.at(t).utc}.first
       end
@@ -84,21 +65,6 @@ module HealthDataStandards
         return ["true","false"].include? (str || "").downcase
       end
       
-      def decode_hqmf_section(section, oid)
-        if oid
-          HealthDataStandards::Util::HQMFTemplateHelper.definition_for_template_id(oid)['definition'].pluralize.to_sym
-        else
-          section
-        end
-      end
-      def decode_hqmf_status(status, oid)
-        if oid
-          HealthDataStandards::Util::HQMFTemplateHelper.definition_for_template_id(oid)['status']
-        else
-          status
-        end
-      end
-      
       def convert_field_to_hash(field, codes)
         if (codes.is_a? Hash)
           clean_hash = {}

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

@@ -0,0 +1,148 @@
+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
+end

data/lib/health-data-standards/import/c32/care_goal_importer.rb

@@ -1,38 +1,26 @@
 module HealthDataStandards
   module Import
     module C32
-      class CareGoalImporter < SectionImporter
+      class CareGoalImporter < CDA::SectionImporter
 
-        def initialize
-          @entry_xpath = "//cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.124']/cda:entry/cda:*[cda:templateId/@root='2.16.840.1.113883.10.20.1.25']"
+        def initialize(entry_finder=CDA::EntryFinder.new("//cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.124']/cda:entry/cda:*[cda:templateId/@root='2.16.840.1.113883.10.20.1.25']"))
+          super(entry_finder)
         end
         
-        def create_entries(doc, id_map = {})
-          goal_list = []
-          goal_elements = doc.xpath(@entry_xpath)
-          goal_elements.each do |goal_element|
-            
-            importer = case goal_element.name
-                       when "observation" then ResultImporter.new
-                       when "supply" then MedicalEquipment.new
-                       when "substanceAdministration" then MedicationImporter.new
-                       when "encounter" then EncounterImporter.new
-                       when "procedure" then ProcedureImporter.new
-                       else SectionImporter.new(nil) #don't need entry xpath, since we already have the entry
+        def create_entry(goal_element, nrh = CDA::NarrativeReferenceHandler.new)
+          importer = case goal_element.name
+                       when "observation" then CDA::ResultImporter.new
+                       when "supply" then CDA::MedicalEquipment.new
+                       when "substanceAdministration" then CDA::MedicationImporter.new
+                       when "encounter" then CDA::EncounterImporter.new
+                       when "procedure" then CDA::ProcedureImporter.new
+                       else CDA::SectionImporter.new(nil) #don't need entry xpath, since we already have the entry
                        end
             
-            entry = importer.create_entry(goal_element, id_map={})
-            extract_negation(goal_element, entry)
+          entry = importer.create_entry(goal_element, nrh)
+          extract_negation(goal_element, entry)
 
-            
-            
-            if @check_for_usable
-              goal_list << entry if entry.usable?
-            else
-              goal_list << entry
-            end
-          end
-          goal_list
+          entry
         end
       end
     end

data/lib/health-data-standards/import/c32/condition_importer.rb

@@ -1,68 +1,29 @@
 module HealthDataStandards
   module Import
     module C32
-      class ConditionImporter < SectionImporter
+      class ConditionImporter < CDA::ConditionImporter
         
         def initialize
-          @entry_xpath = "//cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.103']/cda:entry/cda:act/cda:entryRelationship/cda:observation"
-          @code_xpath = "./cda:value"
-          @status_xpath = "./cda:entryRelationship/cda:observation[cda:templateId/@root='2.16.840.1.113883.10.20.1.50']/cda:value"
-          @ordinality_xpath = "./cda:priorityCode"
-          @description_xpath = "./cda:text/cda:reference[@value]"
-          @provider_xpath = "./cda:act[cda:templateId/@root='2.16.840.1.113883.10.20.1.27']/cda:performer"
-          @cod_xpath = "./cda:entryRelationship[@typeCode='CAUS']/cda:observation/cda:code[@code='419620001']"
-          @priority_xpath = "../cda:sequenceNumber"
+          super
+          @death_xpath = "./cda:entryRelationship[@typeCode='CAUS']/cda:observation"
+          @cod_xpath = "#{@death_xpath}/cda:code[@code='419620001']"
+          @time_of_death_xpath = "#{@death_xpath}/cda:effectiveTime/@value"
         end
         
-        def create_entries(doc, id_map = {})
-          @id_map = id_map
-          condition_list = []
-          entry_elements = doc.xpath(@entry_xpath)
-          
-          entry_elements.each do |entry_element|
-            condition = Condition.new
-            
-            extract_codes(entry_element, condition)
-            extract_dates(entry_element, condition)
-            extract_status(entry_element, condition)
-            extract_ordinality(entry_element, condition)
-            extract_description(entry_element, condition, id_map)
-            extract_cause_of_death(entry_element, condition) if @cod_xpath
-            extract_type(entry_element, condition)
-            extract_negation(entry_element, condition)
-            extract_priority(entry_element, condition)
-
-            if @provider_xpath
-              entry_element.xpath(@provider_xpath).each do |provider_element|
-                condition.treating_provider << import_actor(provider_element)
-              end
-            end
-
-            condition_list << condition
-          end
-          
-          condition_list
+        def create_entry(entry_element, nrh = CDA::NarrativeReferenceHandler.new)
+          condition = super
+          extract_cause_of_death(entry_element, condition)
+          extract_type(entry_element, condition)
+          condition
         end
 
         private
 
-        def extract_ordinality(parent_element, entry)
-          ordinality_element = parent_element.at_xpath(@ordinality_xpath)
-          if ordinality_element
-            entry.ordinality = {CodeSystemHelper.code_system_for(ordinality_element['codeSystem']) => [ordinality_element['code']]}
-          end
-        end
-
         def extract_cause_of_death(entry_element, condition)
           cod = entry_element.at_xpath(@cod_xpath)
           condition.cause_of_death = cod.present?
-        end
-        
-        def extract_priority(entry_element, condition)
-          priority_element = entry_element.at_xpath(@priority_xpath)
-          if priority_element
-            condition.priority = priority_element['value'].to_i
-          end
+          time_of_death = entry_element.at_xpath(@time_of_death_xpath)
+          condition.time_of_death = HL7Helper.timestamp_to_integer(time_of_death.text) if time_of_death
         end
 
         def extract_type(entry_element, condition)