cqm-models 0.7.2

data/app/assets/javascripts/LaboratoryTestOrder.js

@@ -0,0 +1,27 @@
+const mongoose = require('mongoose');
+const { DataElementSchema } = require('./basetypes/DataElement');
+const Code = require('./basetypes/Code');
+const Interval = require('./basetypes/Interval');
+const Quantity = require('./basetypes/Quantity');
+const DateTime = require('./basetypes/DateTime');
+
+const [Number, String] = [
+  mongoose.Schema.Types.Number,
+  mongoose.Schema.Types.String,
+];
+
+const LaboratoryTestOrderSchema = DataElementSchema({
+  authorDatetime: DateTime,
+  reason: Code,
+  method: Code,
+  negationRationale: Code,
+  hqmfOid: { type: String, default: '2.16.840.1.113883.10.20.28.3.41' },
+  category: { type: String, default: 'laboratory_test' },
+  qdmStatus: { type: String, default: 'order' },
+  qdmVersion: { type: String, default: '5.3' },
+  _type: { type: String, default: 'LaboratoryTestOrder' },
+
+});
+
+module.exports.LaboratoryTestOrderSchema = LaboratoryTestOrderSchema;
+module.exports.LaboratoryTestOrder = mongoose.model('LaboratoryTestOrder', LaboratoryTestOrderSchema);

data/app/assets/javascripts/LaboratoryTestPerformed.js

@@ -0,0 +1,33 @@
+const mongoose = require('mongoose');
+const { DataElementSchema } = require('./basetypes/DataElement');
+const Code = require('./basetypes/Code');
+const Interval = require('./basetypes/Interval');
+const Quantity = require('./basetypes/Quantity');
+const DateTime = require('./basetypes/DateTime');
+
+const [Number, String] = [
+  mongoose.Schema.Types.Number,
+  mongoose.Schema.Types.String,
+];
+
+const LaboratoryTestPerformedSchema = DataElementSchema({
+  authorDatetime: DateTime,
+  relevantPeriod: Interval,
+  status: Code,
+  method: Code,
+  result: {},
+  resultDatetime: DateTime,
+  reason: Code,
+  referenceRange: Interval,
+  negationRationale: Code,
+  components: [],
+  hqmfOid: { type: String, default: '2.16.840.1.113883.10.20.28.3.42' },
+  category: { type: String, default: 'laboratory_test' },
+  qdmStatus: { type: String, default: 'performed' },
+  qdmVersion: { type: String, default: '5.3' },
+  _type: { type: String, default: 'LaboratoryTestPerformed' },
+
+});
+
+module.exports.LaboratoryTestPerformedSchema = LaboratoryTestPerformedSchema;
+module.exports.LaboratoryTestPerformed = mongoose.model('LaboratoryTestPerformed', LaboratoryTestPerformedSchema);

data/app/assets/javascripts/LaboratoryTestRecommended.js

@@ -0,0 +1,27 @@
+const mongoose = require('mongoose');
+const { DataElementSchema } = require('./basetypes/DataElement');
+const Code = require('./basetypes/Code');
+const Interval = require('./basetypes/Interval');
+const Quantity = require('./basetypes/Quantity');
+const DateTime = require('./basetypes/DateTime');
+
+const [Number, String] = [
+  mongoose.Schema.Types.Number,
+  mongoose.Schema.Types.String,
+];
+
+const LaboratoryTestRecommendedSchema = DataElementSchema({
+  authorDatetime: DateTime,
+  method: Code,
+  reason: Code,
+  negationRationale: Code,
+  hqmfOid: { type: String, default: '2.16.840.1.113883.10.20.28.3.43' },
+  category: { type: String, default: 'laboratory_test' },
+  qdmStatus: { type: String, default: 'recommended' },
+  qdmVersion: { type: String, default: '5.3' },
+  _type: { type: String, default: 'LaboratoryTestRecommended' },
+
+});
+
+module.exports.LaboratoryTestRecommendedSchema = LaboratoryTestRecommendedSchema;
+module.exports.LaboratoryTestRecommended = mongoose.model('LaboratoryTestRecommended', LaboratoryTestRecommendedSchema);

data/app/assets/javascripts/Measure.js

@@ -0,0 +1,76 @@
+const mongoose = require('mongoose');
+const Code = require('./basetypes/Code');
+const Interval = require('./basetypes/Interval');
+const Quantity = require('./basetypes/Quantity');
+
+const [mNumber, mString, mBoolean, Mixed, ObjectId, mDate] = [
+  mongoose.Schema.Types.Number,
+  mongoose.Schema.Types.String,
+  mongoose.Schema.Types.Boolean,
+  mongoose.Schema.Types.Mixed,
+  mongoose.Schema.Types.ObjectId,
+  mongoose.Schema.Types.Date,
+];
+
+const MeasureSchema = mongoose.Schema(
+  {
+    // ID/other measure information
+    id: mString,
+    measure_id: mString,
+    hqmf_id: mString,
+    hqmf_set_id: mString,
+    hqmf_version_number: mNumber,
+    cms_id: mString,
+    title: mString,
+    description: mString,
+    type: mString,
+    category: { type: mString, default: 'Uncategorized' },
+
+    // Measure type variables
+    episode_of_care: mBoolean,
+    continuous_constiable: mBoolean,
+    episode_ids: [],
+
+    // Publishing data (used by Bonnie)
+    published: mBoolean,
+    publish_date: mDate,
+    version: mNumber,
+
+    // ELM/CQL Measure-logic related data
+    elm_annotations: Mixed,
+    cql: [mString],
+    elm: [Mixed],
+    main_cql_library: mString,
+    cql_statement_dependencies: Mixed,
+
+    // HQMF/Tacoma-specific Measure-logic related data
+    population_criteria: Mixed,
+    data_criteria: Mixed,
+    source_data_criteria: Mixed,
+    measure_period: Interval,
+    measure_attributes: [],
+    populations: [Mixed],
+    populations_cql_map: Mixed,
+    observations: [Mixed],
+
+    value_sets: [{ type: ObjectId, ref: 'ValueSet' }],
+
+    complexity: Mixed, // Bonnie-specific?
+
+    // Relations to other model classes
+    user: { type: ObjectId, ref: 'User', index: true }, // Bonnie-specific
+    bundle: { type: ObjectId, ref: 'Bundle' }, // Cypress-specific, but used in Bonnie-bundler as well
+    package: { type: ObjectId, ref: 'MeasurePackage' }, // Bonnie specific
+  },
+  // Options
+  {
+    timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' }, // These are the Mongoid conventions for timestamps
+  }
+);
+
+MeasureSchema.virtual('ALL_POPULATION_CODES').get(() => ['STRAT', 'IPP', 'DENOM', 'DENEX', 'NUMER', 'NUMEX', 'DENEXCEP', 'MSRPOPL', 'OBSERV', 'MSRPOPLEX']);
+
+MeasureSchema.virtual('cqlSkipStatements').get(() => ['SDE Ethnicity', 'SDE Payer', 'SDE Race', 'SDE Sex']);
+
+module.exports.MeasureSchema = MeasureSchema;
+module.exports.Measure = mongoose.model('measure', MeasureSchema);

data/app/assets/javascripts/MeasurePackage.js

@@ -0,0 +1,20 @@
+const mongoose = require('mongoose');
+
+const [mBuffer, ObjectId] = [
+  mongoose.Schema.Types.Buffer,
+  mongoose.Schema.Types.ObjectId,
+];
+
+const MeasurePackageSchema = mongoose.Schema(
+  {
+    file: mBuffer,
+    measure: { type: ObjectId, ref: 'Measure' },
+  },
+  // Options
+  {
+    timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' },
+  }
+);
+
+module.exports.MeasurePackageSchema = MeasurePackageSchema;
+module.exports.MeasurePackage = mongoose.model('measure_package', MeasurePackageSchema);

data/app/assets/javascripts/MedicationActive.js

@@ -0,0 +1,28 @@
+const mongoose = require('mongoose');
+const { DataElementSchema } = require('./basetypes/DataElement');
+const Code = require('./basetypes/Code');
+const Interval = require('./basetypes/Interval');
+const Quantity = require('./basetypes/Quantity');
+const DateTime = require('./basetypes/DateTime');
+
+const [Number, String] = [
+  mongoose.Schema.Types.Number,
+  mongoose.Schema.Types.String,
+];
+
+const MedicationActiveSchema = DataElementSchema({
+  relevantPeriod: Interval,
+  dosage: Quantity,
+  supply: Quantity,
+  frequency: Code,
+  route: Code,
+  hqmfOid: { type: String, default: '2.16.840.1.113883.10.20.28.3.44' },
+  category: { type: String, default: 'medication' },
+  qdmStatus: { type: String, default: 'active' },
+  qdmVersion: { type: String, default: '5.3' },
+  _type: { type: String, default: 'MedicationActive' },
+
+});
+
+module.exports.MedicationActiveSchema = MedicationActiveSchema;
+module.exports.MedicationActive = mongoose.model('MedicationActive', MedicationActiveSchema);

data/app/assets/javascripts/MedicationAdministered.js

@@ -0,0 +1,31 @@
+const mongoose = require('mongoose');
+const { DataElementSchema } = require('./basetypes/DataElement');
+const Code = require('./basetypes/Code');
+const Interval = require('./basetypes/Interval');
+const Quantity = require('./basetypes/Quantity');
+const DateTime = require('./basetypes/DateTime');
+
+const [Number, String] = [
+  mongoose.Schema.Types.Number,
+  mongoose.Schema.Types.String,
+];
+
+const MedicationAdministeredSchema = DataElementSchema({
+  authorDatetime: DateTime,
+  relevantPeriod: Interval,
+  dosage: Quantity,
+  supply: Quantity,
+  frequency: Code,
+  route: Code,
+  reason: Code,
+  negationRationale: Code,
+  hqmfOid: { type: String, default: '2.16.840.1.113883.10.20.28.3.45' },
+  category: { type: String, default: 'medication' },
+  qdmStatus: { type: String, default: 'administered' },
+  qdmVersion: { type: String, default: '5.3' },
+  _type: { type: String, default: 'MedicationAdministered' },
+
+});
+
+module.exports.MedicationAdministeredSchema = MedicationAdministeredSchema;
+module.exports.MedicationAdministered = mongoose.model('MedicationAdministered', MedicationAdministeredSchema);

data/app/assets/javascripts/MedicationDischarge.js

@@ -0,0 +1,30 @@
+const mongoose = require('mongoose');
+const { DataElementSchema } = require('./basetypes/DataElement');
+const Code = require('./basetypes/Code');
+const Interval = require('./basetypes/Interval');
+const Quantity = require('./basetypes/Quantity');
+const DateTime = require('./basetypes/DateTime');
+
+const [Number, String] = [
+  mongoose.Schema.Types.Number,
+  mongoose.Schema.Types.String,
+];
+
+const MedicationDischargeSchema = DataElementSchema({
+  authorDatetime: DateTime,
+  refills: Number,
+  dosage: Quantity,
+  supply: Quantity,
+  frequency: Code,
+  route: Code,
+  negationRationale: Code,
+  hqmfOid: { type: String, default: '2.16.840.1.113883.10.20.28.3.48' },
+  category: { type: String, default: 'medication' },
+  qdmStatus: { type: String, default: 'discharge' },
+  qdmVersion: { type: String, default: '5.3' },
+  _type: { type: String, default: 'MedicationDischarge' },
+
+});
+
+module.exports.MedicationDischargeSchema = MedicationDischargeSchema;
+module.exports.MedicationDischarge = mongoose.model('MedicationDischarge', MedicationDischargeSchema);

data/app/assets/javascripts/MedicationDispensed.js

@@ -0,0 +1,31 @@
+const mongoose = require('mongoose');
+const { DataElementSchema } = require('./basetypes/DataElement');
+const Code = require('./basetypes/Code');
+const Interval = require('./basetypes/Interval');
+const Quantity = require('./basetypes/Quantity');
+const DateTime = require('./basetypes/DateTime');
+
+const [Number, String] = [
+  mongoose.Schema.Types.Number,
+  mongoose.Schema.Types.String,
+];
+
+const MedicationDispensedSchema = DataElementSchema({
+  authorDatetime: DateTime,
+  relevantPeriod: Interval,
+  refills: Number,
+  dosage: Quantity,
+  supply: Quantity,
+  frequency: Code,
+  route: Code,
+  negationRationale: Code,
+  hqmfOid: { type: String, default: '2.16.840.1.113883.10.20.28.3.49' },
+  category: { type: String, default: 'medication' },
+  qdmStatus: { type: String, default: 'dispensed' },
+  qdmVersion: { type: String, default: '5.3' },
+  _type: { type: String, default: 'MedicationDispensed' },
+
+});
+
+module.exports.MedicationDispensedSchema = MedicationDispensedSchema;
+module.exports.MedicationDispensed = mongoose.model('MedicationDispensed', MedicationDispensedSchema);

data/app/assets/javascripts/MedicationOrder.js

@@ -0,0 +1,34 @@
+const mongoose = require('mongoose');
+const { DataElementSchema } = require('./basetypes/DataElement');
+const Code = require('./basetypes/Code');
+const Interval = require('./basetypes/Interval');
+const Quantity = require('./basetypes/Quantity');
+const DateTime = require('./basetypes/DateTime');
+
+const [Number, String] = [
+  mongoose.Schema.Types.Number,
+  mongoose.Schema.Types.String,
+];
+
+const MedicationOrderSchema = DataElementSchema({
+  activeDatetime: DateTime,
+  relevantPeriod: Interval,
+  authorDatetime: DateTime,
+  refills: Number,
+  dosage: Quantity,
+  supply: Quantity,
+  frequency: Code,
+  route: Code,
+  method: Code,
+  reason: Code,
+  negationRationale: Code,
+  hqmfOid: { type: String, default: '2.16.840.1.113883.10.20.28.3.51' },
+  category: { type: String, default: 'medication' },
+  qdmStatus: { type: String, default: 'order' },
+  qdmVersion: { type: String, default: '5.3' },
+  _type: { type: String, default: 'MedicationOrder' },
+
+});
+
+module.exports.MedicationOrderSchema = MedicationOrderSchema;
+module.exports.MedicationOrder = mongoose.model('MedicationOrder', MedicationOrderSchema);

data/app/assets/javascripts/Participation.js

@@ -0,0 +1,21 @@
+const mongoose = require('mongoose');
+const { DataElementSchema } = require('./basetypes/DataElement');
+const Code = require('./basetypes/Code');
+const Interval = require('./basetypes/Interval');
+const Quantity = require('./basetypes/Quantity');
+const DateTime = require('./basetypes/DateTime');
+
+const [Number, String] = [
+  mongoose.Schema.Types.Number,
+  mongoose.Schema.Types.String,
+];
+
+const ParticipationSchema = DataElementSchema({
+  participationPeriod: Interval,
+  qdmVersion: { type: String, default: '5.3' },
+  _type: { type: String, default: 'Participation' },
+
+});
+
+module.exports.ParticipationSchema = ParticipationSchema;
+module.exports.Participation = mongoose.model('Participation', ParticipationSchema);

data/app/assets/javascripts/Patient.js

@@ -0,0 +1,248 @@
+const mongoose = require('mongoose');
+const Code = require('./basetypes/Code');
+const Interval = require('./basetypes/Interval');
+const Quantity = require('./basetypes/Quantity');
+const DateTime = require('./basetypes/DateTime');
+const AllDataElements = require('./AllDataElements');
+
+const [Schema, Number, String] = [
+  mongoose.Schema,
+  mongoose.Schema.Types.Number,
+  mongoose.Schema.Types.String,
+];
+
+const PatientSchema = new Schema({
+  birthDatetime: DateTime,
+  qdmVersion: { type: String, default: '5.3' },
+  _type: { type: String, default: 'Patient' },
+
+  givenNames: [String],
+  familyName: String,
+  bundleId: String,
+  // These are the "data criteria", or QDM datatype elements that exist on a
+  // patient.
+  dataElements: [],
+  // This field is for application specific information only. If both Bonnie
+  // Cypress use a common field, it should be made a field on this model,
+  // and not put into extendedData.
+  extendedData: {},
+}, { id: false });
+
+// After initialization of a Patient model, initialize every individual data element
+// to its respective Mongoose Model
+PatientSchema.methods.initializeDataElements = function initializeDataElements() {
+  let typeStripped;
+  const dataElementsInit = [];
+  this.dataElements.forEach((element) => {
+    typeStripped = element._type.replace(/QDM::/, '');
+    if (typeStripped in AllDataElements) {
+      dataElementsInit.push(AllDataElements[typeStripped](element));
+    } else {
+      dataElementsInit.push(element);
+    }
+  });
+  this.set({ dataElements: dataElementsInit });
+};
+
+PatientSchema.queue('initializeDataElements');
+
+PatientSchema.methods.id = function id() {
+  return this._id;
+};
+
+// Returns an array of elements that exist on this patient, that
+// match the given HQMF data criteria OID.
+PatientSchema.methods.getByHqmfOid = function getByHqmfOid(hqmfOid) {
+  return this.dataElements.filter(element => element.hqmfOid === hqmfOid);
+};
+
+// Returns an array of elements that exist on this patient, that
+// match the given QRDA data criteria OID.
+PatientSchema.methods.getByQrdaOid = function getByQrdaOid(qrdaOid) {
+  return this.dataElements.filter(element => element.qrdaOid === qrdaOid);
+};
+
+// Returns an array of elements that exist on this patient. Optionally
+// takes a category, which returns all elements of that QDM category.
+// Example: patient.getDataElements(category = 'encounters') will return
+// all Encounter QDM data types active on the patient.
+PatientSchema.methods.getDataElements = function getDataElements(params) {
+  if (params.category && params.qdmStatus) {
+    return this.dataElements.filter(element => (element.category === params.category) && (element.qdmStatus === params.qdmStatus));
+  } else if (params.category) {
+    return this.dataElements.filter(element => element.category === params.category);
+  }
+  return this.dataElements;
+};
+
+// Returns an array of dataElements that exist on the patient, queried by
+// QDM profile
+PatientSchema.methods.getByProfile = function getByProfile(profile, isNegated = null) {
+  if (isNegated === true) {
+    return this.dataElements.filter(element => element._type === `QDM::${profile}` && (typeof element.negationRationale !== 'undefined' && element.negationRationale != null));
+  } else if (isNegated === false) {
+    return this.dataElements.filter(element => element._type === `QDM::${profile}` && (typeof element.negationRationale === 'undefined' || element.negationRationale == null));
+  }
+  return this.dataElements.filter(element => element._type === `QDM::${profile}`);
+};
+
+// This method is called by the CQL execution engine on a CQLPatient when
+// the execution engine wants information on a record. A record could be patient
+// characteristic information about the patient, or it could be data criteria
+// that currently exist on this patient (data criteria you drag on a patient
+// in Bonnie's patient builder).
+// @param {String} profile - the data criteria requested by the execution engine
+// @returns {Object}
+PatientSchema.methods.findRecords = function findRecords(profile) {
+  let profileStripped;
+  if (profile === 'Patient') {
+    // Requested generic patient info
+    return { birthDatetime: this.birthDatetime };
+  } else if (/PatientCharacteristic/.test(profile)) {
+    // Requested a patient characteristic
+    profileStripped = profile.replace(/ *\{[^)]*\} */g, '');
+    return this.getByProfile(profileStripped);
+  } else if (profile != null) {
+    // Requested something else (probably a QDM data type).
+
+    // Strip model details from request. The requested profile string contains
+    // a lot of things we don't need or care about. Example, we might see
+    // something like:
+    // "{urn:healthit-gov:qdm:v5_0_draft}PatientCharacteristicEthnicity"
+    // Where we only care about: "PatientCharacteristicEthnicity".
+    profileStripped = profile.replace(/ *\{[^)]*\} */g, '');
+
+    // Check and handle negation status
+    if (/Positive/.test(profileStripped)) {
+      profileStripped = profileStripped.replace(/Positive/, '');
+      // Since the data criteria is 'Positive', it is not negated.
+      return this.getByProfile(profileStripped, false);
+    } else if (/Negative/.test(profileStripped)) {
+      profileStripped = profileStripped.replace(/Negative/, '');
+      // Since the data criteria is 'Negative', it is negated.
+      return this.getByProfile(profileStripped, true);
+    }
+    // No negation status, proceed normally
+    return this.getByProfile(profileStripped);
+  }
+  return [];
+};
+
+PatientSchema.methods.adverse_events = function adverse_events() {
+  return this.getDataElements({ category: 'adverse_event' });
+};
+
+PatientSchema.methods.allergies = function allergies() {
+  return this.getDataElements({ category: 'allergy' });
+};
+
+PatientSchema.methods.assessments = function assessments() {
+  return this.getDataElements({ category: 'assessment' });
+};
+
+PatientSchema.methods.care_experiences = function care_experiences() {
+  return this.getDataElements({ category: 'care_experience' });
+};
+
+PatientSchema.methods.care_goals = function care_goals() {
+  return this.getDataElements({ category: 'care_goal' });
+};
+
+PatientSchema.methods.communications = function communications() {
+  return this.getDataElements({ category: 'communication' });
+};
+
+PatientSchema.methods.conditions = function conditions() {
+  return this.getDataElements({ category: 'condition' });
+};
+
+PatientSchema.methods.devices = function devices() {
+  return this.getDataElements({ category: 'device' });
+};
+
+PatientSchema.methods.diagnostic_studies = function diagnostic_studies() {
+  return this.getDataElements({ category: 'diagnostic_study' });
+};
+
+PatientSchema.methods.encounters = function encounters() {
+  return this.getDataElements({ category: 'encounter' });
+};
+
+PatientSchema.methods.family_history = function family_history() {
+  return this.getDataElements({ category: 'family_history' });
+};
+
+PatientSchema.methods.functional_statuses = function functional_statuses() {
+  return this.getDataElements({ category: 'functional_status' });
+};
+
+PatientSchema.methods.immunizations = function immunizations() {
+  return this.getDataElements({ category: 'immunization' });
+};
+
+PatientSchema.methods.interventions = function interventions() {
+  return this.getDataElements({ category: 'intervention' });
+};
+
+PatientSchema.methods.laboratory_tests = function laboratory_tests() {
+  return this.getDataElements({ category: 'laboratory_test' });
+};
+
+PatientSchema.methods.medical_equipment = function medical_equipment() {
+  return this.getDataElements({ category: 'medical_equipment' });
+};
+
+PatientSchema.methods.medications = function medications() {
+  return this.getDataElements({ category: 'medication' });
+};
+
+PatientSchema.methods.physical_exams = function physical_exams() {
+  return this.getDataElements({ category: 'physical_exam' });
+};
+
+PatientSchema.methods.preferences = function preferences() {
+  return this.getDataElements({ category: 'preference' });
+};
+
+PatientSchema.methods.provider_characteristics = function provider_characteristics() {
+  return this.getDataElements({ category: 'provider_characteristic' });
+};
+
+PatientSchema.methods.procedures = function procedures() {
+  return this.getDataElements({ category: 'procedure' });
+};
+
+PatientSchema.methods.results = function results() {
+  return this.getDataElements({ category: 'result' });
+};
+
+PatientSchema.methods.risk_category_assessments = function risk_category_assessments() {
+  return this.getDataElements({ category: 'risk_category_assessment' });
+};
+
+PatientSchema.methods.social_history = function social_history() {
+  return this.getDataElements({ category: 'social_history' });
+};
+
+PatientSchema.methods.substances = function substances() {
+  return this.getDataElements({ category: 'substance' });
+};
+
+PatientSchema.methods.symptoms = function symptoms() {
+  return this.getDataElements({ category: 'symptom' });
+};
+
+PatientSchema.methods.system_characteristics = function system_characteristics() {
+  return this.getDataElements({ category: 'system_characteristic' });
+};
+
+PatientSchema.methods.transfers = function transfers() {
+  return this.getDataElements({ category: 'transfer' });
+};
+
+PatientSchema.methods.vital_signs = function vital_signs() {
+  return this.getDataElements({ category: 'vital_sign' });
+};
+
+module.exports.PatientSchema = PatientSchema;
+module.exports.Patient = mongoose.model('Patient', PatientSchema);

data/app/assets/javascripts/PatientCareExperience.js

@@ -0,0 +1,23 @@
+const mongoose = require('mongoose');
+const { DataElementSchema } = require('./basetypes/DataElement');
+const Code = require('./basetypes/Code');
+const Interval = require('./basetypes/Interval');
+const Quantity = require('./basetypes/Quantity');
+const DateTime = require('./basetypes/DateTime');
+
+const [Number, String] = [
+  mongoose.Schema.Types.Number,
+  mongoose.Schema.Types.String,
+];
+
+const PatientCareExperienceSchema = DataElementSchema({
+  authorDatetime: DateTime,
+  hqmfOid: { type: String, default: '2.16.840.1.113883.10.20.28.3.52' },
+  category: { type: String, default: 'care_experience' },
+  qdmVersion: { type: String, default: '5.3' },
+  _type: { type: String, default: 'PatientCareExperience' },
+
+});
+
+module.exports.PatientCareExperienceSchema = PatientCareExperienceSchema;
+module.exports.PatientCareExperience = mongoose.model('PatientCareExperience', PatientCareExperienceSchema);

data/app/assets/javascripts/PatientCharacteristic.js

@@ -0,0 +1,23 @@
+const mongoose = require('mongoose');
+const { DataElementSchema } = require('./basetypes/DataElement');
+const Code = require('./basetypes/Code');
+const Interval = require('./basetypes/Interval');
+const Quantity = require('./basetypes/Quantity');
+const DateTime = require('./basetypes/DateTime');
+
+const [Number, String] = [
+  mongoose.Schema.Types.Number,
+  mongoose.Schema.Types.String,
+];
+
+const PatientCharacteristicSchema = DataElementSchema({
+  authorDatetime: DateTime,
+  hqmfOid: { type: String, default: '2.16.840.1.113883.10.20.28.3.53' },
+  category: { type: String, default: 'patient_characteristic' },
+  qdmVersion: { type: String, default: '5.3' },
+  _type: { type: String, default: 'PatientCharacteristic' },
+
+});
+
+module.exports.PatientCharacteristicSchema = PatientCharacteristicSchema;
+module.exports.PatientCharacteristic = mongoose.model('PatientCharacteristic', PatientCharacteristicSchema);