cqm-models 1.0.3 → 1.1.1.0

data/lib/generate_models.rb

@@ -1,10 +1,10 @@
 #! /usr/bin/env ruby
-
 require 'nokogiri'
 require 'active_support/all'
 require 'rails/generators'
 require 'erb'
 require 'json'
+require_relative './generators/custom_mongo/model_generator'
 
 ###############################################################################
 # Helpers
@@ -82,10 +82,15 @@ qdm_version = modelinfo.xpath('//ns4:modelInfo').first.attributes['version'].val
 # Datatypes (keys are the datatype name, values are the datatype attributes)
 datatypes = {}
 
+# We will export a hqmfOid to datatype map
+hqmfOid_to_datatype_map = {}
+
 # Loop through each typeInfo node (each of these is a QDM datatype)
 modelinfo.xpath('//ns4:typeInfo').each do |type|
   # Grab the name of this QDM datatype
   datatype_name = type.attributes['name'].value.split('.').last
+  # Reject irrelevant datatypes
+  next if datatype_name.include?('Negative') || datatype_name.include?('Positive') || datatype_name.include?('QDMBaseType')
 
   # Grab the QDM attributes for this datatype
   attributes = []
@@ -106,9 +111,27 @@ modelinfo.xpath('//ns4:typeInfo').each do |type|
     attributes << { name: attribute_name, type: attribute_type }
   end
 
-  # Store datatype and its attributes (reject irrelevant datatypes)
-  next if datatype_name.include?('Negative') || datatype_name.include?('Positive') || datatype_name.include?('QDMBaseType')
-  datatypes[datatype_name] = attributes
+  # Add the label as qdmTitle
+  qdm_title = type['label']
+  if qdm_title.nil? # If there's no label, check if there is a "positive" profile
+    positive_profile = modelinfo.at_xpath("/ns4:modelInfo/ns4:typeInfo[@xsi:type='ns4:ProfileInfo'][@identifier='Positive#{datatype_name}']")
+    qdm_title = positive_profile['label'] unless positive_profile.nil?
+  end
+  attributes << { name: 'qdmTitle', type: 'System.String', default: qdm_title } unless qdm_title.nil?
+
+  # Add the extra info that is manually maintained in the "oids" file
+  extra_info = oids[datatype_name.underscore]
+  if extra_info.present?
+    attributes << { name: 'hqmfOid', type: 'System.String', default: extra_info['hqmf_oid'] } if extra_info['hqmf_oid'].present?
+    attributes << { name: 'qrdaOid', type: 'System.String', default: extra_info['qrda_oid'] } if extra_info['qrda_oid'].present?
+    attributes << { name: 'qdmCategory', type: 'System.String', default: extra_info['qdm_category'] } if extra_info['qdm_category'].present?
+    attributes << { name: 'qdmStatus', type: 'System.String', default: extra_info['qdm_status'] } if extra_info['qdm_status'].present?
+    hqmfOid_to_datatype_map[extra_info['hqmf_oid']] = datatype_name if extra_info['hqmf_oid'].present?
+  end
+
+  attributes << { name: 'qdmVersion', type: 'System.String', default: qdm_version }
+
+  datatypes[datatype_name] = { attributes: attributes }
 end
 
 ###############################################################################
@@ -118,25 +141,25 @@ end
 puts 'Generating Ruby models...'
 
 # Do a quick sanity check on attribute types
-datatypes.each do |datatype, attributes|
-  attributes.each do |attribute|
+datatypes.each do |datatype, info|
+  info[:attributes].each do |attribute|
     raise 'Unsupported type from modelinfo file for Ruby types: ' + attribute[:type] + 'from: ' + datatype if TYPE_LOOKUP_RB[attribute[:type]].blank?
     raise 'Unsupported type from modelinfo file for JavaScript types: ' + attribute[:type] + 'from: ' + datatype if TYPE_LOOKUP_JS[attribute[:type]].blank?
   end
 end
 
 # Create Ruby models
-extra_fields_rb = [
-  'hqmfOid:String',
-  'qrdaOid:String',
-  'qdmCategory:String',
-  'qdmStatus:String',
-  'qdmVersion:String'
-]
 base_module = 'QDM::'
 base_module = 'Test::QDM::' if IS_TEST
-datatypes.each do |datatype, attributes|
-  Rails::Generators.invoke('mongoid:model', [base_module + datatype] + attributes.collect { |attribute| attribute[:name] + ':' + TYPE_LOOKUP_RB[attribute[:type]] } + extra_fields_rb)
+datatypes.each do |datatype, info|
+  name = base_module + datatype
+  attributes = info[:attributes].map do |attribute|
+    attribute = attribute.dup
+    attribute[:type] = TYPE_LOOKUP_RB[attribute[:type]]
+    attribute
+  end
+  generator_args = [name, attributes]
+  Rails::Generators.invoke('custom_mongo:model', generator_args)
 end
 
 # Create require file (if not in test mode)
@@ -147,6 +170,12 @@ unless IS_TEST
   File.open(file_path, 'w') { |file| file.puts renderer.result(binding) }
 end
 
+# Javascript PatientSchema for was renamed to QDMPatient since it just contains the QDM data
+if datatypes['Patient']
+  datatypes['QDMPatient'] = datatypes['Patient']
+  datatypes.delete('Patient')
+end
+
 puts 'Generating JavaScript models...'
 
 # Create JavaScript models
@@ -154,25 +183,22 @@ template = File.read('templates/mongoose_template.js.erb')
 default_renderer = ERB.new(template, nil, '-')
 file_path = 'app/assets/javascripts/'
 file_path = 'tmp/' if IS_TEST
-extra_fields_js = [
-  { name: 'hqmfOid', type: 'System.String' },
-  { name: 'qrdaOid', type: 'System.String' },
-  { name: 'qdmCategory', type: 'System.String' },
-  { name: 'qdmStatus', type: 'System.String' },
-  { name: 'qdmVersion', type: 'System.String' },
-  { name: '_type', type: 'System.String' }
-]
 datatype_custom_templates = {
-  Patient: 'templates/patient_template.js.erb',
+  QDMPatient: 'templates/patient_template.js.erb',
   Id: 'templates/id_template.js.erb'
 }
-datatypes.each do |datatype, attributes|
+
+datatypes.each do |datatype, info|
   renderer = default_renderer
   if datatype_custom_templates.key?(datatype.to_sym)
     puts "using custom template for #{datatype}"
     renderer = ERB.new(File.read(datatype_custom_templates[datatype.to_sym]), nil, '-')
   end
-  attrs_with_extras = attributes + extra_fields_js # this field gets used in the template
+  attrs_with_extras = info[:attributes] # this field gets used in the template
+  # Custom datatypes don't need _type
+  unless datatype_custom_templates.key?(datatype.to_sym)
+    attrs_with_extras << { name: '_type', type: 'System.String', default: "QDM::#{datatype.underscore.camelize}" } # Add Class
+  end
   puts '  ' + file_path + datatype + '.js'
   File.open(file_path + datatype + '.js', 'w') { |file| file.puts renderer.result(binding) }
 end
@@ -182,12 +208,18 @@ unless IS_TEST
   indtemplate = File.read('templates/index_template.js.erb')
   renderer = ERB.new(indtemplate, nil, '-')
   file_path = 'app/assets/javascripts/index.js'
+  puts '  ' + file_path
   File.open(file_path, 'w') { |file| file.puts renderer.result(binding) }
 
   alltemplate = File.read('templates/all_data_elements_template.js.erb')
   renderer = ERB.new(alltemplate, nil, '-')
   file_path = 'app/assets/javascripts/AllDataElements.js'
+  puts '  ' + file_path
   File.open(file_path, 'w') { |file| file.puts renderer.result(binding) }
+  contents = File.read(file_path)
+  contents.gsub!(%r{\/FacilityLocation.js}, '/attributes/FacilityLocation.js')
+  contents.gsub!(%r{\/Component.js}, '/attributes/Component.js')
+  File.open(file_path, 'w') { |file| file.puts contents }
 end
 
 ###############################################################################
@@ -205,44 +237,21 @@ Dir.glob(ruby_models_path + '*.rb').each do |file_name|
   # Cut out the 'Any' type placeholder (these attributes could point to anything).
   contents.gsub!(/, type: Any/, '')
 
-  # Add QDM version
-  contents.gsub!(/field :qdmVersion, type: String/, "field :qdmVersion, type: String, default: '#{qdm_version}'")
-
   # Add default to [] for facilityLocations
   contents.gsub!(/field :facilityLocations, type: Array/, 'field :facilityLocations, type: Array, default: []')
 
-  # Add HQMF oid (if it exists in the given HQMF oid mapping file)
-  dc_name = File.basename(file_name, '.*')
-  if oids[dc_name].present? && oids[dc_name]['hqmf_oid'].present?
-    contents.gsub!(/  field :hqmfOid, type: String\n/, "  field :hqmfOid, type: String, default: '#{oids[dc_name]['hqmf_oid']}'\n")
-  else
-    contents.gsub!(/  field :hqmfOid, type: String\n/, '') # Don't include this field
-  end
-
-  # Add QRDA oid (if it exists in the given QRDA oid mapping file)
-  if oids[dc_name].present? && oids[dc_name]['qrda_oid'].present?
-    contents.gsub!(/  field :qrdaOid, type: String\n/, "  field :qrdaOid, type: String, default: '#{oids[dc_name]['qrda_oid']}'\n")
-  else
-    contents.gsub!(/  field :qrdaOid, type: String\n/, '') # Don't include this field
-  end
-
-  # Add category
-  if oids[dc_name].present? && oids[dc_name]['qdm_category'].present?
-    contents.gsub!(/  field :qdmCategory, type: String\n/, "  field :qdmCategory, type: String, default: '#{oids[dc_name]['qdm_category']}'\n")
-  else
-    contents.gsub!(/  field :qdmCategory, type: String\n/, '') # Don't include this field
-  end
-
-  # Add status
-  if oids[dc_name].present? && oids[dc_name]['qdm_status'].present?
-    contents.gsub!(/  field :qdmStatus, type: String\n/, "  field :qdmStatus, type: String, default: '#{oids[dc_name]['qdm_status']}'\n")
-  else
-    contents.gsub!(/  field :qdmStatus, type: String\n/, '') # Don't include this field
-  end
+  # Make facilityLocation of type QDM::FacilityLocation
+  contents.gsub!(/field :facilityLocation, type: Code/, 'field :facilityLocation, type: QDM::FacilityLocation')
 
   # Make relatedTo embeds_many instead of field
   contents.gsub!(/  field :relatedTo, type: Array\n/, "  embeds_many :relatedTo, class_name: 'QDM::Id'\n")
 
+  # Make prescriberId embeds_many instead of field
+  contents.gsub!(/  field :prescriberId, type: Id\n/, "  embeds_one :prescriberId, class_name: 'QDM::Id'\n")
+
+  # Make dispenserId embeds_many instead of field
+  contents.gsub!(/  field :dispenserId, type: Id\n/, "  embeds_one :dispenserId, class_name: 'QDM::Id'\n")
+
   File.open(file_name, 'w') { |file| file.puts contents }
 end
 
@@ -255,41 +264,6 @@ files = Dir.glob(js_models_path + '*.js').each do |file_name|
   # Replace 'Any' type placeholder (these attributes could point to anything).
   contents.gsub!(/: Any/, ': Any')
 
-  # Add QDM version
-  contents.gsub!(/qdmVersion: String/, "qdmVersion: { type: String, default: '#{qdm_version}' }")
-
-  # Add HQMF oid (if it exists in the given HQMF oid mapping file)
-  dc_name = File.basename(file_name.underscore, '.*')
-  if oids[dc_name].present? && oids[dc_name]['hqmf_oid'].present?
-    contents.gsub!(/  hqmfOid: String,\n/, "  hqmfOid: { type: String, default: '#{oids[dc_name]['hqmf_oid']}' },\n")
-  else
-    contents.gsub!(/  hqmfOid: String,\n/, '') # Don't include this field
-  end
-
-  # Add QRDA oid (if it exists in the given QRDA oid mapping file)
-  if oids[dc_name].present? && oids[dc_name]['qrda_oid'].present?
-    contents.gsub!(/  qrdaOid: String,\n/, "  qrdaOid: { type: String, default: '#{oids[dc_name]['qrda_oid']}' },\n")
-  else
-    contents.gsub!(/  qrdaOid: String,\n/, '') # Don't include this field
-  end
-
-  # Add category
-  if oids[dc_name].present? && oids[dc_name]['qdm_category'].present?
-    contents.gsub!(/  qdmCategory: String,\n/, "  qdmCategory: { type: String, default: '#{oids[dc_name]['qdm_category']}' },\n")
-  else
-    contents.gsub!(/  qdmCategory: String,\n/, '') # Don't include this field
-  end
-
-  # Add status
-  if oids[dc_name].present? && oids[dc_name]['qdm_status'].present?
-    contents.gsub!(/  qdmStatus: String,\n/, "  qdmStatus: { type: String, default: '#{oids[dc_name]['qdm_status']}' },\n")
-  else
-    contents.gsub!(/  qdmStatus: String,\n/, '') # Don't include this field
-  end
-
-  # Add class
-  contents.gsub!(/  _type: String,\n/, "  _type: { type: String, default: '#{dc_name.camelize}' },\n")
-
   # Component, Facility, and Id types
   contents.gsub!(/facilityLocations: \[\]/, 'facilityLocations: [FacilityLocationSchema]')
   contents.gsub!(/facilityLocation: Code/, 'facilityLocation: FacilityLocationSchema')
@@ -314,6 +288,7 @@ Dir.glob(ruby_models_path + '*.rb').each do |file_name|
   contents = File.read(file_name)
   contents.gsub!('Qdm', 'QDM')
   contents.gsub!('Code', 'QDM::Code')
+  contents.gsub!(' Id', ' QDM::Id')
   contents.gsub!('Interval', 'QDM::Interval')
   contents.gsub!('Quantity', 'QDM::Quantity')
   File.open(file_name, 'w') { |file| file.puts contents }
@@ -337,7 +312,8 @@ end
 Dir.glob(ruby_models_path + '*.rb').each do |file_name|
   contents = ''
   File.open(file_name).each_line.with_index do |line, index|
-    line.gsub!("\n", " < DataElement\n") if index.zero? && !file_name.include?('/patient.rb') && !file_name.include?('/id.rb')
+    line.gsub!("\n", " < DataElement\n") if index.zero? && !file_name.include?('/patient.rb') && !file_name.include?('/id.rb') && !file_name.include?('/component.rb') && !file_name.include?('/facility_location.rb')
+    line.gsub!("\n", " < Attribute\n") if index.zero? && (file_name.include?('/component.rb') || file_name.include?('/facility_location.rb'))
     contents += "module QDM\n  # #{file_name}\n  #{line.gsub('QDM::', '')}" if index.zero?
     contents += '  ' unless index.zero? || line.blank?
     contents += line unless index.zero?
@@ -346,4 +322,24 @@ Dir.glob(ruby_models_path + '*.rb').each do |file_name|
   File.open(file_name, 'w') { |file| file.puts contents }
 end
 
+puts 'Moving Attribute Schemas To Their Own Directory'
+# Create ruby attributes directory if it doesn't exist, directory won't exist in test mode
+if IS_TEST
+  Dir.mkdir(ruby_models_path + 'attributes')
+  Dir.mkdir(js_models_path + 'attributes')
+end
+if File.exist?(ruby_models_path + 'facility_location.rb')
+  File.rename ruby_models_path + 'facility_location.rb', ruby_models_path + 'attributes/facility_location.rb'
+  File.rename js_models_path + 'FacilityLocation.js', js_models_path + 'attributes/FacilityLocation.js'
+end
+if File.exist?(ruby_models_path + 'component.rb')
+  File.rename ruby_models_path + 'component.rb', ruby_models_path + 'attributes/component.rb'
+  File.rename js_models_path + 'Component.js', js_models_path + 'attributes/Component.js'
+end
+
+puts 'Create hqmfOid to datatype map as json file'
+f = File.open('app/models/hqmfOid_to_datatype_map.json', 'w')
+f.write(JSON.pretty_generate(hqmfOid_to_datatype_map))
+f.close
+
 puts 'Done.'

data/lib/generate_patients.rb

@@ -0,0 +1,125 @@
+require('nokogiri')
+require_relative '../app/models/models'
+require('generate_types')
+
+module QDM
+  # PatientGeneration module can be used to generate patients with dataElements that are populated
+  # with every possible attribute that said type supports
+  module PatientGeneration
+    # Generates patient(s) with fully-loaded dataElements if new_patient_for_each_type is false then a
+    # single patient will be returned that has every data element on it
+    def self.generate_exhastive_data_element_patients(new_patient_for_each_type = true, model_info_file = 'qdm-modelinfo-5.4.xml')
+      datatypes = get_datatypes(File.join(File.dirname(__FILE__), "../modelinfo/#{model_info_file}"))
+      patients = []
+      cqm_patient = nil
+      qdm_patient = nil
+      datatypes.each do |type|
+        next if type.include? 'PatientCharacteristic'
+        # 1 Patient Per data element type containing negated and non-negated type (if negatable)
+        if cqm_patient.nil? || qdm_patient.nil? || new_patient_for_each_type
+          cqm_patient = QDM::BaseTypeGeneration.generate_cqm_patient(type)
+          qdm_patient = QDM::BaseTypeGeneration.generate_qdm_patient
+          # Add patient characteristics
+          sex = generate_loaded_datatype('QDM::PatientCharacteristicSex')
+          race = generate_loaded_datatype('QDM::PatientCharacteristicRace')
+          ethnicity = generate_loaded_datatype('QDM::PatientCharacteristicEthnicity')
+          birthdate = generate_loaded_datatype('QDM::PatientCharacteristicBirthdate')
+          qdm_patient.dataElements.push(sex)
+          qdm_patient.dataElements.push(race)
+          qdm_patient.dataElements.push(ethnicity)
+          qdm_patient.dataElements.push(birthdate)
+          cqm_patient.qdmPatient = qdm_patient
+        end
+        data_element = generate_loaded_datatype(type)
+        qdm_patient.dataElements.push(data_element)
+        # if type is negatable, add a negated version to the patient
+        if data_element.fields.keys.include? 'negationRationale'
+          negated_data_element = generate_loaded_datatype(type, true)
+          qdm_patient.dataElements.push(negated_data_element)
+        end
+        patients.push(cqm_patient)
+      end
+      patients
+    end
+
+    def self.get_datatypes(modelinfo_file)
+      modelinfo = File.open(modelinfo_file) { |f| Nokogiri::XML(f) }
+      datatypes = []
+      # Loop through each typeInfo node (each of these is a QDM datatype)
+      modelinfo.xpath('//ns4:typeInfo').each do |type|
+        # Grab the name of this QDM datatype
+        datatype_name = type.attributes['name'].value.split('.').last
+        exclusion_array = %w[Component Id Patient ResultComponent FacilityLocation]
+        # Store datatype and its attributes (reject irrelevant datatypes)
+        next if datatype_name.include?('Negative') || datatype_name.include?('Positive') ||
+                datatype_name.include?('QDMBaseType') || (exclusion_array.include? datatype_name)
+        datatypes.push(datatype_name)
+      end
+      datatypes
+    end
+
+    def self.generate_loaded_datatype(data_element_type, negate_data_element = false)
+      data_element = QDM.const_get(data_element_type).new
+      fields = data_element.typed_attributes.keys
+      fields.each do |field_name|
+        # Ignore these fields, they are used by mongo
+        next if %w[_id _type].include? field_name
+        if !data_element[field_name] || data_element[field_name] == []
+          populate_fields(field_name, data_element, negate_data_element)
+        end
+      end
+      data_element
+    end
+
+    def self.populate_fields(field_name, data_element, negate_data_element)
+      # There are certain fields that we want to populate manually
+      if field_name == 'description'
+        # Skip the setting of patient description for now
+      elsif field_name == 'codeListId'
+        # Skip the setting code list id. It is not used in a patient's data_element, only in the measure's
+      elsif field_name == 'negationRationale'
+        data_element[field_name] = QDM::BaseTypeGeneration.generate_code_field if negate_data_element
+      elsif field_name == 'components'
+        data_element[field_name] = [QDM::BaseTypeGeneration.generate_component]
+      elsif field_name == 'result'
+        # TODO: Result can be MANY Integer, Decimal, Code, Quantity or Ratio randomize this
+        data_element[field_name] = QDM::BaseTypeGeneration.generate_code_field
+      elsif %w[diagnoses dataElementCodes].include? field_name
+        # TODO: Populate dataElementCodes with codes specifically for data element type
+        data_element[field_name] = [QDM::BaseTypeGeneration.generate_code_field]
+      elsif field_name == 'facilityLocations'
+        # TODO: Randomize number of facility locations added
+        data_element[field_name] = [QDM::BaseTypeGeneration.generate_facility_location]
+      elsif field_name == 'facilityLocation'
+        # TODO: Randomize number of facility locations added
+        data_element[field_name] = QDM::BaseTypeGeneration.generate_facility_location
+      elsif field_name == 'targetOutcome'
+        # TODO: Randomize type of targetOutcome, use code for now
+        data_element[field_name] = QDM::BaseTypeGeneration.generate_code_field
+      else
+        # Fallback to populating fields by expected type
+        populate_field_by_type(field_name, data_element)
+      end
+    end
+
+    def self.populate_field_by_type(field_name, data_element)
+      field_type = data_element.fields[field_name].type
+      if field_type == QDM::Code
+        data_element[field_name] = QDM::BaseTypeGeneration.generate_code_field
+      elsif field_type == DateTime
+        data_element[field_name] = QDM::BaseTypeGeneration.generate_datetime
+      elsif field_type == QDM::Interval
+        data_element[field_name] = QDM::BaseTypeGeneration.generate_date_interval_field
+      elsif field_type == QDM::Quantity
+        data_element[field_name] = QDM::BaseTypeGeneration.generate_quantity
+      elsif field_type == QDM::Id
+        data_element[field_name] = QDM::BaseTypeGeneration.generate_qdm_id
+      elsif field_type == Integer
+        # TODO: randomize value
+        data_element[field_name] = 3
+      else
+        puts("Unknown Type in patient generator for field #{field_name}, type #{field_type} in #{data_element._type}")
+      end
+    end
+  end
+end

data/lib/generate_types.rb

@@ -0,0 +1,64 @@
+require_relative '../app/models/models'
+
+module QDM
+  # BaseTypeGeneration contains functions to randomly generate basetypes used by PatientGeneration
+  module BaseTypeGeneration
+    def self.generate_component
+      component = QDM::Component.new
+      component.code = generate_code_field
+      # TODO: Randomize the type of the result
+      component.result = generate_code_field
+      component
+    end
+
+    def self.generate_facility_location
+      facility_location = QDM::FacilityLocation.new
+      facility_location.code = generate_code_field
+      facility_location.locationPeriod = generate_date_interval_field
+      facility_location
+    end
+
+    def self.generate_code_field
+      # TODO: use code with all parameters, possibly randomize parameter values and optional information
+      QDM::Code.new('1234', 'SNOMEDCT')
+    end
+
+    def self.generate_datetime
+      # TODO: Randomize dateTime
+      DateTime.new(2019)
+    end
+
+    def self.generate_quantity
+      # TODO: Randomize value and parameters for Quantity
+      QDM::Quantity.new(100, 'mg')
+    end
+
+    def self.generate_date_interval_field
+      # TODO: Randomize dates in interval and open/closed parameters
+      QDM::Interval.new(DateTime.new(2018), DateTime.new(2019))
+    end
+
+    def self.generate_cqm_patient(type)
+      cqm_patient = CQM::Patient.new
+      cqm_patient.givenNames = [type]
+      cqm_patient.familyName = "#{type} Test Patient"
+      cqm_patient
+    end
+
+    def self.generate_qdm_patient
+      qdm_patient = QDM::Patient.new
+      qdm_patient.extendedData = {}
+      qdm_patient.extendedData['medical_record_number'] = '1'
+      qdm_patient.birthDatetime = generate_datetime
+      qdm_patient
+    end
+
+    def self.generate_qdm_id
+      # TODO: randomize values
+      qdm_id = QDM::Id.new
+      qdm_id.value = 'TestValue'
+      qdm_id.namingSystem = 'TestNamingSystem'
+      qdm_id
+    end
+  end
+end