test-patient-generator 1.0.2 → 1.1.0

data/lib/tpg/ext/value.rb

@@ -1,83 +1,38 @@
 module HQMF
   class Value
-    include Comparable
-    
-    # Perform a deep copy of this Value.
+    # Translate a Ruby time object to an HL7 timestamp string (YYYYMMDD).
     #
-    # @return A deep copy of this Value.
-    def clone
-      Value.new(type.try(:clone), unit.try(:clone), value.try(:clone), inclusive?, derived?, expression.try(:clone))
-    end
-
-    #
-    def format      
-#      unit_mapping = {"a" => "years", "mo" => "months", "wk" => "weeks", "d" => "days"}
-#      pretty_unit = unit_mapping[unit] if unit
-#      pretty_unit ||= unit
-      
-      { "scalar" => value, "units" => unit }
+    # @return An HL7 timestamp string (YYYYMMDD) equivalent to time.
+    def self.time_to_ts(time)
+      time.strftime("%Y%m%d%H%M%S")
     end
 
-    # 
+    # Translate an HQMF Value object into a shape that HealthDataStandards understands.
     #
-    # @param [Value] value1
-    # @param [Value] value2
-    # @return 
-    def self.merge_values(value1, value2)
-      # If only one value in the range is defined, we have no work to do
-      return value1 if value2.nil?
-      return value2 if value1.nil?
-      
-      if value1.type == "PQ" && value2.type == "PQ"
-        # TODO Combine the value of two PQs. This will be tough if there is a case of time units and no relative TS
-        
-      elsif value1.type == "TS" && value2.type == "TS"
-        # Convert the time strings that we have into actual time objects
-        
-      else
-        # One PQ and one TS
-        pq = value1.type == "PQ" ? value1 : value2
-        ts = value1.type == "TS" ? value1 : value2
-        
-        # Create a Ruby object to represent the TS
-        year = ts.value[0,4]
-        month = ts.value[4,2]
-        day = ts.value[6,2]
-        time = Time.new(year, month, day)
-        
-        # Advance that time forward the amount the PQ specifies. Convert units to symbols for advance function.
-        pq.value += 1 unless pq.inclusive?
-        unit_mapping = {"a" => :years, "mo" => :months, "wk" => :weeks, "d" => :days}
-        time = time.advance({unit_mapping[pq.unit] => pq.value.to_i})
-        
-        # Form up the modified TS with expected YYYYMMDD formatting (avoid YYYYMD)
-        year = time.year
-        month = time.month < 10 ? "0#{time.month}" : time.month
-        day = time.day < 10 ? "0#{time.day}" : time.day
-        
-        Value.new("TS", value1.unit, "#{year}#{month}#{day}", value1.inclusive? && value2.inclusive?, false, false)
+    # @return A Value formatted for storing a HealthDataStandards Record.
+    def format
+      if type == "PQ"
+        { "scalar" => value, "units" => unit }
+      elsif type == "TS"
+        to_seconds
       end
     end
     
-    def self.time_to_ts(time)
-      year = time.year
-      month = time.month < 10 ? "0#{time.month}" : time.month
-      day = time.day < 10 ? "0#{time.day}" : time.day
-      
-      "#{year}#{month}#{day}"
-    end
-    
+    # Translate the time stored in this Value into epoch seconds.
     #
-    #
-    # @return
+    # @return Epoch seconds equivalent to the time stored in this Value.
     def to_seconds
-      to_time_object.to_i
+      return nil unless type == "TS"
+
+      to_time_object.utc.to_i
     end
     
-    # 
+    # Translate the time represented by this Value into a Ruby time object.
     #
-    # @return 
+    # @return A Ruby time object equivalent to the time represented by this Value.
     def to_time_object
+      return nil unless type == "TS"
+
       year = value[0,4].to_i
       month = value[4,2].to_i
       day = value[6,2].to_i
@@ -90,23 +45,7 @@ module HQMF
         second = value[12,2].to_i
       end
       
-      Time.new(year, month, day, hour, minute, second)
-    end
-    
-    def <=>(value)
-      # So far there has only been a need to compare TS Values
-      if type == "TS" && value.type == "TS"
-        time = to_time_object
-        other = value.value
-        
-        if time < other
-          -1
-        elsif time > other
-          1
-        else
-          0
-        end
-      end
+      Time.gm(year, month, day, hour, minute, second)
     end
   end
 end

data/lib/tpg/generation/exporter.rb

@@ -36,11 +36,12 @@ module TPG
       file
     end
     
-    # Export QRDA Category 1 patients to a zip file. Contents are organized with a directory for each measure containing one patient for validation.
+    # Export QRDA Category 1 patients to a zip file.
+    # Contents are organized with a directory for each measure containing one patient for validation.
     #
     # @param [Hash] measure_patients Measures mapped to the patient that was generated for it.
     # @return A zip file containing all of the QRDA Category 1 patients that were passed in.
-    def self.zip_qrda_patients(measure_patients)
+    def self.zip_qrda_html_patients(measure_patients)
       file = Tempfile.new("patients-#{Time.now.to_i}")
       
       Zip::ZipOutputStream.open(file.path) do |zip|
@@ -55,40 +56,21 @@ module TPG
       file.close
       file
     end
-    
-    # Export a list of patients to a zip file. Contains the proper formatting of a patient bundle for Cypress,
-    # i.e. a bundle JSON file with four subdirectories for c32, ccr, html, and JSON formatting for patients.
+
+    # Export QRDA Category 1 patients to a zip file.
+    # Contents are organized with a directory for each measure containing one patient for validation.
     #
-    # @param [Array] patients All of the patients that will be exported.
-    # @param [String] version The version to mark the bundle.json file of this archive.
-    # @return A bundle containing all of the QRDA Category 1 patients that were passed in.
-    def self.zip_bundle(patients, name, version)
+    # @param [Hash] measure_patients Measures mapped to the patient that was generated for it.
+    # @return A zip file containing all of the QRDA Category 1 patients that were passed in.
+    def self.zip_qrda_cat_1_patients(measure_patients, measures)
       file = Tempfile.new("patients-#{Time.now.to_i}")
       
       Zip::ZipOutputStream.open(file.path) do |zip|
-        # Generate the bundle file
-        zip.put_next_entry("bundle.json")
-        zip << {name: name, version: version}.to_json
-        
-        xslt = Nokogiri::XSLT(File.read("public/cda.xsl"))
-        patients.each_with_index do |patient, index|
-          filename = "#{index}_#{patient_filename(patient)}"
-          
-          # Define path names
-          c32_path = File.join("patients", "c32", "#{filename}.xml")
-          ccr_path = File.join("patients", "ccr", "#{filename}.xml")
-          html_path = File.join("patients", "html", "#{filename}.html")
-          json_path = File.join("patients", "json", "#{filename}.json")
-          
-          # For each patient add a C32, CCR, HTML, and JSON file.
-          zip.put_next_entry(c32_path)
-          zip << HealthDataStandards::Export::C32.export(patient)
-          zip.put_next_entry(ccr_path)
-          zip << HealthDataStandards::Export::CCR.export(patient)
-          zip.put_next_entry(html_path)
-          zip << html_contents(patient)
-          zip.put_next_entry(json_path)
-          zip << JSON.pretty_generate(JSON.parse(patient.to_json))
+        measure_patients.each do |nqf_id, patient|
+          measure_defs = measures.find {|m| m.id == nqf_id}
+          # Create a directory for this measure and insert the HTML for this patient.
+          zip.put_next_entry(File.join(measure_defs.hqmf_id, "#{patient_filename(patient)}.xml"))
+          zip << QrdaGenerator::Export::Cat1.export(patient, [measure_defs], Time.gm(2011, 1, 1), Time.gm(2011, 12, 31))
         end
       end
       

data/lib/tpg/generation/generator.rb

@@ -1,49 +1,33 @@
 module HQMF
-  # The generator will create as many patients as possible to exhaustively test the logic of a given clinical quality measure.
   class Generator
-    # TODO - This is a hack and a half. Need a better way to resolve data_criteria from any point in the tree.
-    class << self
-      attr_accessor :hqmf
-      attr_accessor :value_sets
-    end
-    
-    # @param [HQMF::Document] hqmf A model representing the logic of a given HQMF document.
-    # @param [Hash] value_sets All of the value sets referenced by this particular HQMF document.
-    def initialize(hqmf, value_sets)
-      @patients = []
-      Generator.hqmf = hqmf
-      Generator.value_sets = value_sets
-    end
-    
     # Generate patients from lists of DataCriteria. This is originally created for QRDA Category 1 validation testing,
     # i.e. a single patient will be generated per measure with an entry for every data criteria involved in the measure.
     # 
-    # @param [Hash] measure_needs A hash of measure IDs mapped to a list of all their data criteria.
-    # @param [Hash] measure_value_sets A hash of measure IDs mapped to hashes of value sets used by the DataCriteria in measure_needs.
+    # @param [Hash] measure_needs A hash of measure IDs mapped to a list of all their data criteria in JSON.
     # @return [Hash] A hash of measure IDs mapped to a Record that includes all the given data criteria (values and times are arbitrary).
-    def self.generate_qrda_patients(measure_needs, measure_value_sets)
+    def self.generate_qrda_patients(measure_needs)      
       return {} if measure_needs.nil?
       
       measure_patients = {}
       measure_needs.each do |measure, all_data_criteria|
-        # Prune out all data criteria that create similar entries. Category 1 validation is only checking for ability to access information
-        # so to minimize time we only want to include each kind of data once.
-        unique_data_criteria = []
-        all_data_criteria.each do |data_criteria|
-          index = unique_data_criteria.index {|dc| dc.code_list_id == data_criteria.code_list_id && dc.negation_code_list_id == data_criteria.negation_code_list_id && dc.field_values == data_criteria.field_values && dc.status == data_criteria.status}
-          unique_data_criteria << data_criteria if index.nil?
-        end
+        # Define a list of unique data criteria and matching value sets to create a patient for this measure.
+        unique_data_criteria = select_unique_data_criteria(all_data_criteria)
+        oids = select_unique_oids(all_data_criteria)
+        value_sets = create_oid_dictionary(oids)
         
         # Create a patient that includes an entry for every data criteria included in this measure.
         patient = Generator.create_base_patient
         unique_data_criteria.each do |data_criteria|
           # Ignore data criteria that are really just containers.
           next if data_criteria.derivation_operator.present?
-          
-          # Generate a random time for this data criteria and apply it to the patient.
-          time = Randomizer.randomize_range(patient.birthdate, nil)
-          data_criteria.modify_patient(patient, time, measure_value_sets[measure])
+
+          # Prepare and apply our parameters for modifying the patient based on the data criteria.
+          time = select_valid_time_range(patient, data_criteria)
+          apply_field_defaults(data_criteria, time)
+          data_criteria.modify_patient(patient, time, value_sets)
         end
+
+        # Add final data for the patient, e.g. that they were designed for the measure, possibly a birthdate, etc.
         patient.measure_ids ||= []
         patient.measure_ids << measure
         patient.type = "qrda"
@@ -53,45 +37,9 @@ module HQMF
       measure_patients
     end
     
-    # Generate patients from an HQMF file and its matching value sets file. These patients are designed to test all
-    # paths through the logic of this particular clinical quality measure.
-    def generate_patients
-      base_patients = [Generator.create_base_patient]
-      generated_patients = []
-      
-      # Gather all available populations. Each kind of population (e.g. IPP, DENOM) can have many multiples (e.g. IPP_1, IPP_2)
-      populations = []
-      ["IPP", "DENOM", "NUMER", "EXCL", "DENEXCEP"].each do |population|
-        i = 1
-        populations << population
-        while Generator.hqmf.population_criteria("#{population}_#{i}").present? do
-          populations << "#{population}_#{i}"
-          i += 1
-        end
-      end
-
-      populations = ["EXCL_1"]
-
-      populations.each do |population|
-        criteria = Generator.hqmf.population_criteria(population)
-        
-        # We don't need to do anything for populations with nothing specified
-        next if criteria.nil? || !criteria.preconditions.present?
-        criteria.generate(base_patients)  
-        
-        # Mark the patient we just created with its expected population. Then extend the Record to be augmented by the next population.
-        base_patients.collect! do |patient|
-          generated_patients.push(Generator.finalize_patient(patient))
-          Generator.extend_patient(patient)
-        end
-      end
-      
-      generated_patients
-    end
-    
     # Create a patient with trivial demographic information and no coded entries.
     #
-    # @return A Record with a blank slate
+    # @return A Record with a blank slate.
     def self.create_base_patient(initial_attributes = nil)
       patient = Record.new
       
@@ -100,20 +48,10 @@ module HQMF
       else
         initial_attributes.each {|attribute, value| patient.send("#{attribute}=", value)}
       end
-      patient.medical_record_number = Digest::MD5.hexdigest("#{patient.first} #{patient.last}")
       
       patient
     end
-    
-    # Take an existing patient with some coded entries on them and redefine their trivial demographic information
-    #
-    # @param [Record] base_patient The patient that we're using as a base to create a new one
-    # @return A new Record with an identical medical history to the given patient but new trivial demographic information
-    def self.extend_patient(base_patient)
-      patient = base_patient.clone()
-      Randomizer.randomize_demographics(patient)
-    end
-    
+        
     # Fill in any missing details that should be filled in on a patient. These include: age, gender, and first name.
     #
     # @param [Record] patient The patient for whom we are about to fill in remaining demographic information.
@@ -125,19 +63,155 @@ module HQMF
       end
       
       if patient.gender.nil?
-        # Set gender
         patient.gender = "F"
-        #rand(2) == 0 ? patient.gender = "M" : patient.gender = "F"
-        patient.first = Randomizer.randomize_first_name(patient.gender)
+        patient.first ||= Randomizer.randomize_first_name(patient.gender)
       end
       
       patient
     end
-    
+
+    # Select all unique data criteria from a list. Category 1 validation is only checking for ability to access information
+    # so to minimize time we only want to include each kind of data once.
     #
+    # @param [Array] all_data_criteria A list of HQMF::DataCriteria to be sifted through.
+    # @return The unique list of data criteria extracted from all_data_criteria
+    def self.select_unique_data_criteria(all_data_criteria)
+      all_data_criteria.flatten!
+      all_data_criteria.uniq!
+      
+      unique_data_criteria = []
+      all_data_criteria.each do |data_criteria|
+        index = unique_data_criteria.index {|dc| dc.code_list_id == data_criteria.code_list_id && dc.negation_code_list_id == data_criteria.negation_code_list_id && dc.field_values == data_criteria.field_values && dc.status == data_criteria.status}
+        unique_data_criteria << data_criteria if index.nil?
+      end
+
+      unique_data_criteria
+    end
+
+    # 
     #
-    # @param [String] type 
+    # @param [Array] oids 
     # @return 
+    def self.create_oid_dictionary(oids)
+      value_sets = []
+      HealthDataStandards::SVS::ValueSet.any_in(oid: oids).each do |value_set|
+        code_sets = value_set.concepts.map { |concept| {"code_set" => concept.code_system_name, "codes" => [concept.code]} }
+        value_sets << {"code_sets" => code_sets, "oid" => value_set.oid, "concept" => value_set.display_name}
+      end
+
+      value_sets
+    end
+
+    #
+    #
+    # @param [Array] all_data_criteria
+    # @return
+    def self.select_unique_oids(all_data_criteria)
+      oids = []
+      all_data_criteria.each do |dc|
+        oids << dc.code_list_id if dc.code_list_id.present?
+        oids << dc.negation_code_list_id if dc.negation_code_list_id.present?
+        oids << dc.value.code_list_id if dc.value.present? && dc.value.type == "CD"
+
+        dc.field_values.each {|name, field| oids << field.code_list_id if field.present? && field.type == "CD"} if dc.field_values.present?
+      end
+
+      oids << "2.16.840.1.113883.3.117.1.7.1.70"
+      oids << "2.16.840.1.113883.3.117.2.7.1.14"
+
+      oids.flatten!
+      oids.uniq!
+      oids.compact
+    end
+
+    # Create a random time range for an entry to occur. It is guaranteed to be within the lifespan of the patient and will last no longer than a day.
+    #
+    # @param [Record] patient The patient for whom this range is being generated.
+    # @param [HQMF::DataCriteria] data_criteria The data criteria for which we're creating an entry.
+    # @return A time range that can be used to create an entry for this data criteria.
+    def self.select_valid_time_range(patient, data_criteria)
+      earliest_time = patient.birthdate
+      latest_time = patient.deathdate
+
+      # Make sure all ranges occur within the bounds of birth and death. If this data criteria is deciding one of those two, place this range outside of our 35 year range for entries.
+      if data_criteria.property.present?
+        if data_criteria.property == :birthtime
+          earliest_time = HQMF::Randomizer.randomize_birthdate(patient)
+          latest_time = earliest_time.advance(days: 1)
+        elsif data_criteria.property == :expired
+          earliest_time = Time.now
+          latest_time = earliest_time.advance(days: 1)
+        end
+      end
+
+      time = Randomizer.randomize_range(earliest_time, latest_time, {days: 1})
+    end
+
+    #
+    #
+    # @param [HQMF::DataCriteria] date_criteria
+    # @return
+    def self.apply_field_defaults(data_criteria, time)
+      return nil if data_criteria.field_values.nil?
+
+      # Some fields come in with no value or marked as AnyValue (i.e. any value is acceptable, there just must be one). If that's the case, we pick a default here.
+      data_criteria.field_values.each do |name, field|
+        if field.is_a? HQMF::AnyValue
+          if ["ADMISSION_DATETIME", "START_DATETIME", "INCISION_DATETIME"].include? name
+            data_criteria.field_values[name] = time.low
+          elsif ["DISCHARGE_DATETIME", "STOP_DATETIME", "REMOVAL_DATETIME"].include? name
+            data_criteria.field_values[name] = time.high
+          elsif name == "REASON"
+            # If we're not explicitly given a code (e.g. HQMF dictates there must be a reason but any is ok), we assign a random one (birth)
+            data_criteria.field_values[name] = Coded.for_code_list("2.16.840.1.113883.3.117.1.7.1.70", "birth")
+          elsif name == "ORDINAL"
+            # If we're not explicitly given a code (e.g. HQMF dictates there must be a reason but any is ok), we assign it to be not principle
+            data_criteria.field_values[name] = Coded.for_code_list("2.16.840.1.113883.3.117.2.7.1.14", "principle")
+          end
+        end
+      end
+    end
+
+    # Takes an Array of meassures and builds a Hash keyed by NQF ID with the values being an Array of data criteria.
+    #
+    # @param [Array] measures A list of HQMF::Documents for which patients will be generated.
+    # @return A hash of measure IDs for which we're generating patients, mapped to an array of HQMF::DataCriteria.
+    def self.determine_measure_needs(measures)
+      measure_needs = {}
+      measures.each do |measure|
+        measure_needs[measure.id] = measure.all_data_criteria
+      end
+
+      measure_needs
+    end
+
+    # Parses a JSON representation of a measure from a Bonnie Bundle into an hqmf-parser ready format.
+    #
+    # @param [Hash] measure JSON representation of a measure
+    # @return Tweaked JSON that has fields in the places hqmf-parser expects
+    def self.parse_measure(measure_json)
+      # HQMF Parser expects just a hash of ID => data_criteria, so translate to that format here.
+      translated_data_criteria = {}
+      measure_json["data_criteria"].each { |data_criteria| translated_data_criteria[data_criteria.keys.first] = data_criteria.values.first }
+      measure_json["data_criteria"] = translated_data_criteria
+      
+      # HQMF::Documents have fields for hqmf_id and id, but not NQF ID. We'll store NQF_ID in ID.
+      measure_json["id"] = measure_json["nqf_id"]
+      measure_json["source_data_criteria"] = []
+
+      measure = HQMF::Document.from_json(measure_json)
+      measure.all_data_criteria.each do |data_criteria|
+        data_criteria.values ||= []
+        data_criteria.values << data_criteria.value if data_criteria.value && data_criteria.value.type != "ANYNonNull"
+      end
+
+      measure
+    end
+    
+    # Map all patient api coded entry types from HQMF data criteria to Record sections.
+    #
+    # @param [String] type The type of the coded entry requried by a data criteria.
+    # @return The section type for the given patient api function type
     def self.classify_entry(type)
       # The possible matches per patientAPI function can be found in hqmf-parser's README
       case type
@@ -146,7 +220,7 @@ module HQMF
       when :proceduresPerformed
         "procedures"
       when :procedureResults
-        "lab_results"
+        "procedures"
       when :laboratoryTests
         "vital_signs"
       when :allMedications
@@ -166,4 +240,4 @@ module HQMF
       end
     end
   end
-end
+end