cqm-models 2.0.1 → 3.0.4

data/lib/generate_entities.rb

@@ -0,0 +1,56 @@
+require_relative '../app/models/models'
+require('generate_types')
+
+module QDM
+  # BaseTypeGeneration contains functions to randomly generate basetypes used by PatientGeneration
+  module EntityGeneration
+    def self.generate_entities(data_element)
+      data_element.performer = generate_entity if data_element.respond_to? 'performer'
+      data_element.recorder = generate_entity if data_element.respond_to? 'recorder'
+      data_element.requester = generate_entity if data_element.respond_to? 'requester'
+      data_element.sender = generate_entity if data_element.respond_to? 'sender'
+      data_element.recipient = generate_entity if data_element.respond_to? 'recipient'
+      data_element.participant = generate_entity if data_element.respond_to? 'participant'
+      data_element.prescriber = generate_entity if data_element.respond_to? 'prescriber'
+      data_element.dispenser = generate_entity if data_element.respond_to? 'dispenser'
+    end
+
+    def self.generate_entity
+      case Random.rand(4)
+      when 0 then return generate_patient_entity
+      when 1 then return generate_care_partner_entity
+      when 2 then return generate_organization_entity
+      when 3 then return generate_practitioner_entity
+      end
+    end
+
+    def self.generate_patient_entity
+      patient_entity = QDM::PatientEntity.new
+      patient_entity.identifier = QDM::BaseTypeGeneration.generate_qdm_id
+      patient_entity
+    end
+
+    def self.generate_care_partner_entity
+      care_partner_entity = QDM::CarePartner.new
+      care_partner_entity.identifier = QDM::BaseTypeGeneration.generate_qdm_id
+      care_partner_entity.relationship = QDM::BaseTypeGeneration.generate_code_field
+      care_partner_entity
+    end
+
+    def self.generate_organization_entity
+      organization_entity = QDM::Organization.new
+      organization_entity.identifier = QDM::BaseTypeGeneration.generate_qdm_id
+      organization_entity.type = QDM::BaseTypeGeneration.generate_code_field
+      organization_entity
+    end
+
+    def self.generate_practitioner_entity
+      practitioner_entity = QDM::Practitioner.new
+      practitioner_entity.identifier = QDM::BaseTypeGeneration.generate_qdm_id
+      practitioner_entity.role = QDM::BaseTypeGeneration.generate_code_field
+      practitioner_entity.specialty = QDM::BaseTypeGeneration.generate_code_field
+      practitioner_entity.qualification = QDM::BaseTypeGeneration.generate_code_field
+      practitioner_entity
+    end
+  end
+end

data/lib/generate_models.rb

@@ -1,10 +1,14 @@
-#! /usr/bin/env ruby
+# TODO: May need to add Entity casting to Any if entities need to be handled
+# TODO: HQMF OIDS - Specifically RelatedPerson
+
+# ! /usr/bin/env ruby
 require 'nokogiri'
 require 'active_support/all'
 require 'rails/generators'
 require 'erb'
 require 'json'
 require_relative './generators/custom_mongo/model_generator'
+require_relative './generator_helpers'
 
 ###############################################################################
 # Helpers
@@ -13,10 +17,11 @@ require_relative './generators/custom_mongo/model_generator'
 # Lookups for modelinfo 'element types' to Ruby+Mongoid types.
 TYPE_LOOKUP_RB = {
   'System.DateTime': 'DateTime',
+  'System.Date': 'Date',
   'System.Integer': 'Integer',
   'System.Quantity': 'Quantity',
   'System.Code': 'Code',
-  'QDM.Id': 'Id',
+  'QDM.Identifier': 'Identifier',
   'System.Any': 'Any',
   'interval<System.DateTime>': 'Interval',
   'interval<System.Quantity>': 'Interval',
@@ -25,6 +30,8 @@ TYPE_LOOKUP_RB = {
   'list<QDM.Id>': 'Array',
   'list<QDM.ResultComponent>': 'Array',
   'list<QDM.FacilityLocation>': 'Array',
+  'list<QDM.DiagnosisComponent>': 'Array',
+  'list<System.String>': 'Array',
   'list<System.Code>': 'Array',
   'System.Decimal': 'Float',
   'System.Time': 'Time',
@@ -34,11 +41,12 @@ TYPE_LOOKUP_RB = {
 # Lookups for modelinfo 'element types' to JavaScript+Mongoose types.
 TYPE_LOOKUP_JS = {
   'System.DateTime': 'DateTime',
+  'System.Date': 'QDMDate',
   'System.Integer': 'Number',
   'System.Quantity': 'Quantity',
   'System.Code': 'Code',
   'System.Any': 'Any',
-  'QDM.Id': 'IdSchema',
+  'QDM.Identifier': 'IdentifierSchema',
   'interval<System.DateTime>': 'Interval',
   'interval<System.Quantity>': 'Interval',
   'list<QDM.Component>': '[]',
@@ -46,6 +54,8 @@ TYPE_LOOKUP_JS = {
   'list<QDM.Id>': '[]',
   'list<QDM.ResultComponent>': '[]',
   'list<QDM.FacilityLocation>': '[]',
+  'list<QDM.DiagnosisComponent>': '[]',
+  'list<System.String>': '[]',
   'list<System.Code>': '[Code]',
   'System.Decimal': 'Number',
   'System.Time': 'DateTime',
@@ -65,11 +75,13 @@ puts Dir.entries('.')
 # Open specified modelinfo file
 modelinfo_file = ARGV[0]
 raise 'Please provide a valid modelinfo file path and name.' if modelinfo_file.blank? || !File.file?(modelinfo_file)
+
 modelinfo = File.open(modelinfo_file) { |f| Nokogiri::XML(f) }
 
 # Open specified HQMF oid file
 oids_file = ARGV[1]
 raise 'Please provide a valid HQMF oid file path and name.' if oids_file.blank? || !File.file?(oids_file)
+
 oids = JSON.parse(File.read(oids_file))
 
 # If this script was run with a third parameter of 'TEST', then generate the models in a
@@ -129,7 +141,8 @@ modelinfo.xpath('//ns4:typeInfo').each do |type|
     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 }
+  # Add the qdmVersion attribute unless the base type is one that will provide it
+  attributes << { name: 'qdmVersion', type: 'System.String', default: qdm_version } unless ['QDM.Entity', 'QDM.Component'].include? type['baseType']
 
   datatypes[datatype_name] = { attributes: attributes }
 end
@@ -185,7 +198,7 @@ file_path = 'app/assets/javascripts/'
 file_path = 'tmp/' if IS_TEST
 datatype_custom_templates = {
   QDMPatient: 'templates/patient_template.js.erb',
-  Id: 'templates/id_template.js.erb'
+  Identifier: 'templates/identifier_template.js.erb'
 }
 
 datatypes.each do |datatype, info|
@@ -195,8 +208,8 @@ datatypes.each do |datatype, info|
     renderer = ERB.new(File.read(datatype_custom_templates[datatype.to_sym]), nil, '-')
   end
   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)
+  # QDMPatients don't need _type
+  unless datatype.to_s == 'QDMPatient'
     attrs_with_extras << { name: '_type', type: 'System.String', default: "QDM::#{datatype.underscore.camelize}" } # Add Class
   end
   puts '  ' + file_path + datatype + '.js'
@@ -219,6 +232,14 @@ unless IS_TEST
   contents = File.read(file_path)
   contents.gsub!(%r{\/FacilityLocation.js}, '/attributes/FacilityLocation.js')
   contents.gsub!(%r{\/Component.js}, '/attributes/Component.js')
+  contents.gsub!(%r{\/CarePartner.js}, '/attributes/CarePartner.js')
+  contents.gsub!(%r{\/DiagnosisComponent.js}, '/attributes/DiagnosisComponent.js')
+  contents.gsub!(%r{\/Entity.js}, '/attributes/Entity.js')
+  contents.gsub!(%r{\/Organization.js}, '/attributes/Organization.js')
+  contents.gsub!(%r{\/PatientEntity.js}, '/attributes/PatientEntity.js')
+  contents.gsub!(%r{\/Practitioner.js}, '/attributes/Practitioner.js')
+  contents.gsub!(%r{\/ResultComponent.js}, '/attributes/ResultComponent.js')
+  contents.gsub!(%r{\/Identifier.js}, '/attributes/Identifier.js')
   File.open(file_path, 'w') { |file| file.puts contents }
 end
 
@@ -243,14 +264,16 @@ Dir.glob(ruby_models_path + '*.rb').each do |file_name|
   # 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")
+  # Make Entity subclasses of type QDM::Entity
+  contents.gsub!(/field :participant/, "embeds_one :participant, class_name: 'QDM::Entity'")
+  contents.gsub!(/field :sender/, "embeds_one :sender, class_name: 'QDM::Entity'")
+  contents.gsub!(/field :recipient/, "embeds_one :recipient, class_name: 'QDM::Entity'")
+  contents.gsub!(/field :recorder/, "embeds_one :recorder, class_name: 'QDM::Entity'")
+  contents.gsub!(/field :performer/, "embeds_one :performer, class_name: 'QDM::Entity'")
+  contents.gsub!(/field :requester/, "embeds_one :requester, class_name: 'QDM::Entity'")
+  contents.gsub!(/field :prescriber/, "embeds_one :prescriber, class_name: 'QDM::Entity'")
+  contents.gsub!(/field :dispenser/, "embeds_one :dispenser, class_name: 'QDM::Entity'")
+  contents.gsub!(/field :identifier, type: Identifier/, "embeds_one :identifier, class_name: 'QDM::Identifier'")
 
   File.open(file_name, 'w') { |file| file.puts contents }
 end
@@ -258,28 +281,35 @@ end
 # JavaScript post processing
 js_models_path = 'app/assets/javascripts/'
 js_models_path = 'tmp/' if IS_TEST
-files = Dir.glob(js_models_path + '*.js').each do |file_name|
+Dir.glob(js_models_path + '*.js').each do |file_name|
   contents = File.read(file_name)
 
   # Replace 'Any' type placeholder (these attributes could point to anything).
   contents.gsub!(/: Any/, ': Any')
 
-  # Component, Facility, and Id types
+  # Component, Facility, Diagnoses
   contents.gsub!(/facilityLocations: \[\]/, 'facilityLocations: [FacilityLocationSchema]')
   contents.gsub!(/facilityLocation: Code/, 'facilityLocation: FacilityLocationSchema')
   contents.gsub!(/components: \[\]/, 'components: [ComponentSchema]')
   contents.gsub!(/component: Code/, 'component: ComponentSchema')
-  contents.gsub!(/relatedTo: \[\]/, 'relatedTo: [IdSchema]')
+  contents.gsub!(/diagnoses: \[\]/, 'diagnoses: [DiagnosisComponentSchema]')
+  contents.gsub!(/sender: Any/, 'sender: AnyEntity')
+  contents.gsub!(/recipient: Any/, 'recipient: AnyEntity')
+  contents.gsub!(/participant: Any/, 'participant: AnyEntity')
+  contents.gsub!(/recorder: Any/, 'recorder: AnyEntity')
+  contents.gsub!(/performer: Any/, 'performer: AnyEntity')
+  contents.gsub!(/requester: Any/, 'requester: AnyEntity')
+  contents.gsub!(/prescriber: Any/, 'prescriber: AnyEntity')
+  contents.gsub!(/dispenser: Any/, 'dispenser: AnyEntity')
+  contents.gsub!(/relatedTo: \[\]/, 'relatedTo: [String]')
 
   File.open(file_name, 'w') { |file| file.puts contents }
 end
 
 # Inject Ruby Patient model extensions
-template = File.read('templates/patient_extension.rb.erb')
-renderer = ERB.new(template, nil, '-')
-rb_patient = File.read(ruby_models_path + 'patient.rb')
-rb_patient.gsub!(/end/, renderer.result(binding))
-File.open(ruby_models_path + 'patient.rb', 'w') { |file| file.write(rb_patient) }
+GeneratorHelpers.inject_extension('templates/patient_extension.rb.erb', ruby_models_path + 'patient.rb')
+# Inject Ruby Entity model extensions
+GeneratorHelpers.inject_extension('templates/entity_extension.rb.erb', ruby_models_path + 'entity.rb') if datatypes['Entity']
 
 # Make sure Ruby models are in the correct module
 ruby_models_path = 'app/models/qdm/'
@@ -288,23 +318,29 @@ 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!('Date\n', 'QDM::Date\n') # \n so DateTime does not get overwritten
+  contents.gsub!(' Identifier', ' QDM::Identifier')
   contents.gsub!('Interval', 'QDM::Interval')
   contents.gsub!('Quantity', 'QDM::Quantity')
   File.open(file_name, 'w') { |file| file.puts contents }
 end
 
+types_not_inherited_by_data_element = ['/patient.rb', '/identifier.rb', '/component.rb', '/facility_location.rb', '/entity.rb', '/organization.rb', '/patient_entity.rb', '/practitioner.rb', '/care_partner.rb', '/diagnosis_component.rb', '/result_component.rb']
+types_inherited_by_attribute = ['/component', '/facility_location', '/entity', '/diagnosis_component', '/identifier']
+types_inherited_by_entity = ['/patient_entity', '/care_partner', '/practitioner', '/organization']
+types_inherited_by_component = ['/result_component']
+
 # Set embedded in for datatypes
 Dir.glob(ruby_models_path + '*.rb').each do |file_name|
   contents = File.read(file_name)
-  # TODO: Might be able to make this list by finding baseType="System.Any" in model info file instead of hard-coding.
-  if File.basename(file_name) == 'id.rb'
+  if ['entity.rb', 'organization.rb', 'patient_entity.rb', 'practitioner.rb', 'care_partner.rb'].any? { |sub_string| sub_string.include?(File.basename(file_name)) }
     contents.gsub!(/  include Mongoid::Document\n/, "  include Mongoid::Document\n  embedded_in :data_element\n")
-  else
-    not_embedded_in_patient_files = ['patient.rb', 'component.rb', 'facility_location.rb']
-    next if not_embedded_in_patient_files.include?(File.basename(file_name))
-    contents.gsub!(/  include Mongoid::Document\n/, "  include Mongoid::Document\n  embedded_in :patient\n")
+    File.open(file_name, 'w') { |file| file.puts contents }
   end
+  # TODO: Might be able to make this list by finding baseType="System.Any" in model info file instead of hard-coding.
+  next if types_not_inherited_by_data_element.any? { |sub_string| sub_string.include?(File.basename(file_name)) }
+
+  contents.gsub!(/  include Mongoid::Document\n/, "  include Mongoid::Document\n  embedded_in :patient\n")
   File.open(file_name, 'w') { |file| file.puts contents }
 end
 
@@ -312,8 +348,10 @@ 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') && !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'))
+    line.gsub!("\n", " < DataElement\n") if index.zero? && types_not_inherited_by_data_element.none? { |sub_string| file_name.include?(sub_string) }
+    line.gsub!("\n", " < Attribute\n") if index.zero? && types_inherited_by_attribute.any? { |sub_string| file_name.include?(sub_string) }
+    line.gsub!("\n", " < Entity\n") if index.zero? && types_inherited_by_entity.any? { |sub_string| file_name.include?(sub_string) }
+    line.gsub!("\n", " < Component\n") if index.zero? && types_inherited_by_component.any? { |sub_string| file_name.include?(sub_string) }
     contents += "module QDM\n  # #{file_name}\n  #{line.gsub('QDM::', '')}" if index.zero?
     contents += '  ' unless index.zero? || line.blank?
     contents += line unless index.zero?
@@ -328,13 +366,13 @@ 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'
+
+attribute_list = types_inherited_by_attribute + types_inherited_by_component + types_inherited_by_entity
+existing_types_moving_to_attributes = attribute_list.select { |sub_string| File.exist?(ruby_models_path + sub_string + '.rb') }
+existing_types_moving_to_attributes.each do |type|
+  modified_name = type[1..-1]
+  File.rename ruby_models_path + modified_name + '.rb', ruby_models_path + 'attributes/' + modified_name + '.rb'
+  File.rename js_models_path + modified_name.camelize + '.js', js_models_path + 'attributes/' + modified_name.camelize + '.js'
 end
 
 puts 'Create hqmfOid to datatype map as json file'

data/lib/generate_patients.rb

@@ -1,6 +1,7 @@
 require('nokogiri')
 require_relative '../app/models/models'
 require('generate_types')
+require('generate_entities')
 
 module QDM
   # PatientGeneration module can be used to generate patients with dataElements that are populated
@@ -8,13 +9,14 @@ module QDM
   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')
+    def self.generate_exhaustive_data_element_patients(new_patient_for_each_type = true, model_info_file = 'qdm-modelinfo-5.5.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)
@@ -33,7 +35,7 @@ module QDM
         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'
+        if data_element.fields.key?('negationRationale')
           negated_data_element = generate_loaded_datatype(type, true)
           qdm_patient.dataElements.push(negated_data_element)
         end
@@ -49,10 +51,11 @@ module QDM
       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]
+        exclusion_array = %w[Component Identifier 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
@@ -64,10 +67,11 @@ module QDM
       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
+
+        populate_fields(field_name, data_element, negate_data_element) if !data_element[field_name] || data_element[field_name] == []
       end
+      QDM::EntityGeneration.generate_entities(data_element)
+      data_element.identifier = QDM::BaseTypeGeneration.generate_qdm_id if data_element.respond_to? 'identifier'
       data_element
     end
 
@@ -81,17 +85,19 @@ module QDM
         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
+      elsif field_name == 'dataElementCodes'
         # TODO: Populate dataElementCodes with codes specifically for data element type
+        # might need to build a large map of data element type to relevent codes
+        # should also be done for <data element type>.attribute -> relevant code for the coded attributes
         data_element[field_name] = [QDM::BaseTypeGeneration.generate_code_field]
+      elsif field_name == 'diagnoses'
+        data_element[field_name] = [QDM::BaseTypeGeneration.generate_diagnosis]
+      elsif field_name == 'result'
+        data_element[field_name] = QDM::BaseTypeGeneration.generate_result
       elsif field_name == 'facilityLocations'
-        # TODO: Randomize number of facility locations added
-        data_element[field_name] = [QDM::BaseTypeGeneration.generate_facility_location]
+        # create up to 5 facility locations
+        data_element[field_name] = (0..rand(5)).map { 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
@@ -112,7 +118,7 @@ module QDM
         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
+      elsif field_type == QDM::Identifier
         data_element[field_name] = QDM::BaseTypeGeneration.generate_qdm_id
       elsif field_type == Integer
         # TODO: randomize value

data/lib/generate_types.rb

@@ -3,11 +3,20 @@ require_relative '../app/models/models'
 module QDM
   # BaseTypeGeneration contains functions to randomly generate basetypes used by PatientGeneration
   module BaseTypeGeneration
+    def self.generate_diagnosis
+      diagnosis_component = QDM::DiagnosisComponent.new
+      diagnosis_component.code = generate_code_field
+      diagnosis_component.presentOnAdmissionIndicator = generate_code_field
+      diagnosis_component.rank = 1
+      diagnosis_component
+    end
+
     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.result type values: Integer, Decimal, Code, Quantity, Ratio, DateTime, Time (from modelinfo file)
+      # low occurence rate in 2020/2021 measures, so may not randomized to include DateTime/Time yet
+      component.result = generate_result
       component
     end
 
@@ -19,23 +28,39 @@ module QDM
     end
 
     def self.generate_code_field
-      # TODO: use code with all parameters, possibly randomize parameter values and optional information
-      QDM::Code.new('1234', '2.16.840.1.113883.6.96')
+      # relevant code systems as of March 2020
+      code_sys = ['2.16.840.1.113883.6.96', '2.16.840.1.113883.6.90', '2.16.840.1.113883.6.103',
+                  '2.16.840.1.113883.6.104', '2.16.840.1.113883.6.12', '2.16.840.1.113883.6.88',
+                  '2.16.840.1.113883.6.1', '2.16.840.1.113883.12.292', '2.16.840.1.113883.6.285',
+                  '2.16.840.1.113883.6.4', '2.16.840.1.113883.6.14', '2.16.840.1.113883.6.13']
+
+      # 1-15 digit codes
+      code = rand(1_000_000_000_000_000)
+      QDM::Code.new(code.to_s, code_sys[rand(12)], 'Display Name', '2018-09')
     end
 
     def self.generate_datetime
-      # TODO: Randomize dateTime
-      DateTime.new(2019)
+      # Does not give a random time... just randomizes the date +/-365000 days
+      rand(DateTime.now - 36_500..DateTime.now + 36_500)
     end
 
     def self.generate_quantity
-      # TODO: Randomize value and parameters for Quantity
-      QDM::Quantity.new(100, 'mg')
+      # TODO: randomize for no unit situation?
+
+      # pulled from realistic units (UCUM)
+      # https://vsac.nlm.nih.gov/valueset/2.16.840.1.113883.1.11.12839/expansion/Latest
+      unit = ['%', '/10*10', '10*12/L', 'K', 'U/(10.g){feces}', '[IU]/g', 'cm', 'erg',
+              'g/L', 'kat', 'mA', 'osm', 's/{control}', '{CPM}', '{Pan_Bio\'U}', '{mutation}']
+      QDM::Quantity.new(rand(0.0..10_000.0), unit[rand(16)])
     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))
+      date1 = generate_datetime
+      date2 = generate_datetime
+
+      # endure low before high
+      # randomly true/false lowClosed and highClosed parameters
+      QDM::Interval.new([date1, date2].min, [date1, date2].max, rand(2).zero?, rand(2).zero?)
     end
 
     def self.generate_cqm_patient(type)
@@ -54,11 +79,26 @@ module QDM
     end
 
     def self.generate_qdm_id
-      # TODO: randomize values
-      qdm_id = QDM::Id.new
-      qdm_id.value = 'TestValue'
-      qdm_id.namingSystem = 'TestNamingSystem'
+      # could also randomize length of string
+      qdm_id = QDM::Identifier.new
+      qdm_id.value = random_string(12) # 'TestValue'
+      qdm_id.namingSystem = random_string(12) # 'TestNamingSystem'
       qdm_id
     end
+
+    def self.generate_result
+      # minimum allowed set Integer (converts incorrectly for tests), Decimal, Code, Quantity, Ratio
+      # sometimes allowed to be DateTime, Time, or Date in certain contexts (from modelinfo file)
+      case Random.rand(3)
+      when 0 then return rand(0.0..10_000.0)
+      when 1 then return generate_code_field
+      when 2 then return generate_quantity
+      end
+    end
+
+    def self.random_string(length)
+      # create and array of size length and map to a random character from ! (33) to ~ (126)
+      [*'a'..'z', *'A'..'Z'].sample(length).join
+    end
   end
 end