cqm-models 1.1.1.0 → 3.0.2

data/app/assets/javascripts/attributes/ResultComponent.js

@@ -0,0 +1,31 @@
+const mongoose = require('mongoose/browser');
+
+const { ComponentSchemaFunction } = require('./Component');
+const Code = require('../basetypes/Code');
+const Interval = require('../basetypes/Interval');
+const Quantity = require('../basetypes/Quantity');
+const DateTime = require('../basetypes/DateTime');
+const QDMDate = require('../basetypes/QDMDate');
+const Any = require('../basetypes/Any');
+
+const [Number, String] = [
+  mongoose.Schema.Types.Number,
+  mongoose.Schema.Types.String,
+];
+
+const ResultComponentSchema = ComponentSchemaFunction({
+  referenceRange: Interval,
+  _type: { type: String, default: 'QDM::ResultComponent' },
+
+});
+
+module.exports.ResultComponentSchema = ResultComponentSchema;
+class ResultComponent extends mongoose.Document {
+  constructor(object) {
+    super(object, ResultComponentSchema);
+    this._type = 'QDM::ResultComponent';
+  }
+}
+
+module.exports.ResultComponent = ResultComponent;
+

data/app/assets/javascripts/basetypes/Any.js

@@ -8,31 +8,31 @@ Any.prototype = Object.create(mongoose.SchemaType.prototype);
 
 function RecursiveCast(any) {
   if (any && any.value && any.unit) {
-    return new cql.Quantity(any);
+    return new cql.Quantity(any.value, any.unit);
   }
-  if (any && any.code && any.codeSystem) {
-    if (typeof any.code === 'undefined') {
-      throw new Error(`Code: ${any} does not have a code`);
-    } else if (typeof any.codeSystem === 'undefined') {
-      throw new Error(`Code: ${any} does not have a codeSystem`);
-    }
 
-    const val = { code: any.code, codeSystem: any.codeSystem };
+  if (any.isCode || any.isConcept || any.isValueSet || any.isList ||
+      any.isDateTime || any.isDate || any.isRatio || any.isQuantiy ||
+      any.isInterval || any.isBooleanLiteral || any.isIntegerLiteral ||
+      any.isDecimalLiteral || any.isStringLiteral || any.isTuple) {
+    return any;
+  }
 
-    val.descriptor = (typeof any.descriptor !== 'undefined') ? any.descriptor : null;
-    val.codeSystemOid = (typeof any.codeSystemOid !== 'undefined') ? any.codeSystemOid : null;
+  if (any && any.code && any.system) {
+    const val = { code: any.code, system: any.system };
+    val.display = (typeof any.display !== 'undefined') ? any.display : null;
     val.version = (typeof any.version !== 'undefined') ? any.version : null;
 
-    return new cql.Code(val.code, val.codeSystem, val.version, val.descriptor);
+    return new cql.Code(val.code, val.system, val.version, val.display);
   }
   if (any && any.low) {
     const casted = new cql.Interval(any.low, any.high, any.lowClosed, any.highClosed);
 
     // Cast Low and High values to Quantities if it is a quantity
     if (casted.low && casted.low.unit && casted.low.value) {
-      casted.low = new cql.Quantity(casted.low);
+      casted.low = new cql.Quantity(casted.low.value, casted.low.unit);
       if (casted.high && casted.high.unit && casted.high.value) {
-        casted.high = new cql.Quantity(casted.high);
+        casted.high = new cql.Quantity(casted.high.value, casted.high.unit);
       }
       return casted;
     }
@@ -56,8 +56,17 @@ function RecursiveCast(any) {
   if (Number.isFinite(any)) {
     return any;
   }
-  if (Date.parse(any)) {
-    return cql.DateTime.fromJSDate(new Date(any), 0);
+  if (Date.parse(any) || Date.parse(`1984-01-01T${any}`)) {
+    if (any.match(/T/) || any.match(/\+/)) {
+      // If it has a T or a timezoneoffset, it must be a DateTime
+      return cql.DateTime.fromJSDate(new Date(any), 0);
+    }
+    if (any.match(/:/)) {
+      // If it has a : but no T or timezoneoffset, it must be a Time
+      return cql.DateTime.fromJSDate(new Date(`1984-01-01T${any}`), 0).getTime();
+    }
+    // Must be a Date
+    return cql.DateTime.fromJSDate(new Date(any), 0).getDate();
   }
   return any;
 }

data/app/assets/javascripts/basetypes/AnyEntity.js

@@ -0,0 +1,44 @@
+const mongoose = require('mongoose/browser');
+const { PatientEntity } = require('../attributes/PatientEntity');
+const { Practitioner } = require('../attributes/Practitioner');
+const { CarePartner } = require('../attributes/CarePartner');
+const { Organization } = require('../attributes/Organization');
+
+function AnyEntity(key, options) {
+  mongoose.SchemaType.call(this, key, options, 'AnyEntity');
+}
+AnyEntity.prototype = Object.create(mongoose.SchemaType.prototype);
+
+AnyEntity.prototype.cast = (entity) => {
+  if (entity == null) {
+    return null;
+  }
+
+  if (entity instanceof PatientEntity || entity instanceof Practitioner || entity instanceof CarePartner || entity instanceof Organization) {
+    return entity;
+  }
+
+  if (entity._type != null) {
+    // copy _id to id if it isn't defined
+    if (entity.id == null && entity._id != null) {
+      entity.id = entity._id;
+    }
+    switch (entity._type) {
+      case 'QDM::PatientEntity':
+        return new PatientEntity(entity);
+      case 'QDM::Practitioner':
+        return new Practitioner(entity);
+      case 'QDM::CarePartner':
+        return new CarePartner(entity);
+      case 'QDM::Organization':
+        return new Organization(entity);
+      default:
+        throw new Error(`Could not find entity type "${entity._type}".`);
+    }
+  } else {
+    throw new Error('Could not find _type indicator for entity.');
+  }
+};
+
+mongoose.Schema.Types.AnyEntity = AnyEntity;
+module.exports = AnyEntity;

data/app/assets/javascripts/basetypes/Code.js

@@ -8,21 +8,17 @@ Code.prototype = Object.create(mongoose.SchemaType.prototype);
 
 Code.prototype.cast = (code) => {
   if (code != null) {
+    // return code if it doesn't even need casting
+    if (code.isCode) {
+      return code;
+    }
     // handles codes that have not yet been cast to a code and those that have already been cast to a code
-    if (code.code && (code.codeSystem || code.system)) {
-      if (typeof code.code === 'undefined') {
-        throw new Error(`Code: ${code} does not have a code`);
-      } else if (typeof code.codeSystem === 'undefined' && typeof code.system === 'undefined') {
-        throw new Error(`Code: ${code} does not have a system`);
-      }
-
-      const val = { code: code.code, codeSystem: code.codeSystem || code.system };
-
-      val.descriptor = (typeof code.descriptor !== 'undefined') ? code.descriptor : null;
-      val.codeSystemOid = (typeof code.codeSystemOid !== 'undefined') ? code.codeSystemOid : null;
+    if (code.code && code.system) {
+      const val = { code: code.code, system: code.system };
+      val.display = (typeof code.display !== 'undefined') ? code.display : null;
       val.version = (typeof code.version !== 'undefined') ? code.version : null;
 
-      return new cql.Code(val.code, val.codeSystem, val.version, val.descriptor);
+      return new cql.Code(val.code, val.system, val.version, val.display);
     }
     throw new Error(`Expected a code. Received ${code}.`);
   } else {

data/app/assets/javascripts/basetypes/DataElement.js

@@ -1,19 +1,19 @@
 const mongoose = require('mongoose/browser');
 const Code = require('./Code.js');
 const cql = require('cql-execution');
-const Id = require('../Id');
+const Identifier = require('../attributes/Identifier');
 
 const [Schema] = [mongoose.Schema];
 
 function DataElementSchema(add, options) {
   const extended = new Schema({
-    dataElementCodes: { type: [] },
+    dataElementCodes: { type: [Code] },
     description: { type: String },
     codeListId: { type: String },
     id: {
-      type: Id.IdSchema,
+      type: String,
       default() {
-        return new Id.Id({ value: (this._id ? this._id.toString() : mongoose.Types.ObjectId().toString()), namingSystem: null });
+        return this._id ? this._id.toString() : mongoose.Types.ObjectId().toString();
       },
     },
   }, options);
@@ -25,7 +25,15 @@ function DataElementSchema(add, options) {
   // Returns all of the codes on this data element in a format usable by
   // the cql-execution framework.
   extended.methods.getCode = function getCode() {
-    return this.dataElementCodes.map(code => new cql.Code(code.code, code.codeSystem, code.version, code.descriptor));
+    if (this.dataElementCodes) {
+      return this.dataElementCodes.map((code) => {
+        if (code.isCode) {
+          return code;
+        }
+        return new cql.Code(code.code, code.system, code.version, code.display);
+      });
+    }
+    return null;
   };
 
   // Return the first code on this data element in a format usable by
@@ -33,7 +41,10 @@ function DataElementSchema(add, options) {
   extended.methods.code = function code() {
     if (this.dataElementCodes && this.dataElementCodes[0]) {
       const qdmCode = this.dataElementCodes[0];
-      return new cql.Code(qdmCode.code, qdmCode.codeSystem, qdmCode.version, qdmCode.descriptor);
+      if (qdmCode.isCode) {
+        return qdmCode;
+      }
+      return new cql.Code(qdmCode.code, qdmCode.system, qdmCode.version, qdmCode.display);
     }
     return null;
   };

data/app/assets/javascripts/basetypes/Interval.js

@@ -1,5 +1,6 @@
 const mongoose = require('mongoose/browser');
 const cql = require('cql-execution');
+const DateTime = require('./DateTime');
 
 function Interval(key, options) {
   mongoose.SchemaType.call(this, key, options, 'Interval');
@@ -7,26 +8,27 @@ function Interval(key, options) {
 Interval.prototype = Object.create(mongoose.SchemaType.prototype);
 
 Interval.prototype.cast = (interval) => {
-  if (typeof interval.low === 'undefined' || interval.low === null) {
-    throw new Error(`Interval: ${interval} does not have a low value`);
+  if (interval.isInterval) {
+    return interval;
   }
   const casted = new cql.Interval(interval.low, interval.high, interval.lowClosed, interval.highClosed);
 
   // Cast Low and High values to Quantities if it is a quantity
   if (casted.low && casted.low.unit && casted.low.value) {
-    casted.low = new cql.Quantity(casted.low);
+    casted.low = new cql.Quantity(casted.low.value, casted.low.unit);
     if (casted.high && casted.high.unit && casted.high.value) {
-      casted.high = new cql.Quantity(casted.high);
+      casted.high = new cql.Quantity(casted.high.value, casted.high.unit);
     }
     return casted;
   }
 
   // Cast to DateTime if it is a string representing a DateTime
-  if (casted.low && Date.parse(casted.low)) {
-    casted.low = cql.DateTime.fromJSDate(new Date(casted.low), 0);
+  if (casted.low) {
+    casted.low = DateTime.prototype.cast(casted.low);
   }
-  if (casted.high && Date.parse(casted.high)) {
-    casted.high = cql.DateTime.fromJSDate(new Date(casted.high), 0);
+
+  if (casted.high) {
+    casted.high = DateTime.prototype.cast(casted.high);
   }
   return casted;
 };

data/app/assets/javascripts/basetypes/QDMDate.js

@@ -0,0 +1,36 @@
+const mongoose = require('mongoose/browser');
+const cql = require('cql-execution');
+
+function QDMDate(key, options) {
+  mongoose.SchemaType.call(this, key, options, 'Date');
+}
+QDMDate.prototype = Object.create(mongoose.SchemaType.prototype);
+
+QDMDate.prototype.cast = (date) => {
+  if (date == null) {
+    return date;
+  }
+
+  // Already a CQL Date
+  if (date.isDate) {
+    return date;
+  }
+
+  // Object
+  if (typeof date === 'object') {
+    const keys = Object.keys(date);
+    if (keys.includes('year') && keys.includes('month') && keys.includes('day')) {
+      return new cql.Date(date.year, date.month, date.day);
+    }
+  }
+
+  // Date String
+  if (!cql.Date.parse(date)) {
+    throw new Error(`Date: ${date} is not a valid Date`);
+  } else {
+    return cql.Date.parse(date);
+  }
+};
+
+mongoose.Schema.Types.QDMDate = QDMDate;
+module.exports = QDMDate;

data/app/assets/javascripts/basetypes/Quantity.js

@@ -13,7 +13,7 @@ Quantity.prototype.cast = (quantity) => {
     throw new Error(`Quantity: ${quantity} does not have a unit`);
   }
 
-  return new cql.Quantity(quantity);
+  return new cql.Quantity(quantity.value, quantity.unit);
 };
 
 mongoose.Schema.Types.Quantity = Quantity;

data/app/assets/javascripts/basetypes/Ratio.js

@@ -13,7 +13,7 @@ Ratio.prototype.cast = (ratio) => {
     throw new Error(`Ratio: ${ratio} does not have a denominator`);
   }
 
-  return new cql.Ratio(ratio);
+  return new cql.Ratio(ratio.numerator, ratio.denominator);
 };
 
 mongoose.Schema.Types.Ratio = Ratio;

data/app/assets/javascripts/cqm/AllCQMModels.js

@@ -22,3 +22,5 @@ module.exports.Patient = require('./Patient.js').Patient;
 module.exports.PatientSchema = require('./Patient.js').PatientSchema;
 module.exports.Provider = require('./Provider.js').Provider;
 module.exports.ProviderSchema = require('./Provider.js').ProviderSchema;
+module.exports.IndividualResult = require('./IndividualResult.js').IndividualResult;
+module.exports.IndividualResultSchema = require('./IndividualResult.js').IndividualResultSchema;

data/app/assets/javascripts/cqm/ClauseResult.js

@@ -0,0 +1,28 @@
+const mongoose = require('mongoose/browser');
+
+const [String, Mixed] = [
+  mongoose.Schema.Types.String,
+  mongoose.Schema.Types.Mixed,
+];
+
+const ClauseResultSchema = mongoose.Schema({
+  // Library the clause this result is for is in
+  library_name: String,
+  // Statement the clause this result is for is in
+  statement_name: String,
+  // LocalId of the clause this result is for
+  localId: String,
+  // Final, processed result of raw calculation
+  final: String,
+  // Raw result of clause calculation
+  raw: Mixed,
+});
+
+
+module.exports.ClauseResultSchema = ClauseResultSchema;
+class ClauseResult extends mongoose.Document {
+  constructor(object) {
+    super(object, ClauseResultSchema);
+  }
+}
+module.exports.ClauseResult = ClauseResult;

data/app/assets/javascripts/{IndividualResult.js → cqm/IndividualResult.js}

@@ -1,4 +1,6 @@
 const mongoose = require('mongoose/browser');
+const { ClauseResultSchema } = require('./ClauseResult');
+const { StatementResultSchema } = require('./StatementResult');
 
 const [Number, String, Mixed, ObjectId] = [
   mongoose.Schema.Types.Number,
@@ -22,9 +24,11 @@ const IndividualResultSchema = mongoose.Schema(
     MSRPOPLEX: Number,
 
     // Result Attributes
-    clause_results: Mixed,
+    clause_results: [ClauseResultSchema],
+    statement_results: [StatementResultSchema],
+    population_relevance: Mixed,
     episode_results: Mixed,
-    statement_results: Mixed,
+    observation_values: [Number],
 
     // This field is for application specific information only. If both Bonnie and
     // Cypress use a common field, it should be made a field on this model,
@@ -53,6 +57,28 @@ const IndividualResultSchema = mongoose.Schema(
   }
 );
 
+IndividualResultSchema.methods.clause_results_by_clause = function clause_results_by_clause() {
+  const clause_results_hash = {};
+  this.clause_results.forEach((result) => {
+    if (!clause_results_hash[result.library_name]) {
+      clause_results_hash[result.library_name] = {};
+    }
+    clause_results_hash[result.library_name][result.localId] = result;
+  });
+  return clause_results_hash;
+};
+
+IndividualResultSchema.methods.statement_results_by_statement = function statement_results_by_statement() {
+  const statement_results_hash = {};
+  this.statement_results.forEach((result) => {
+    if (!statement_results_hash[result.library_name]) {
+      statement_results_hash[result.library_name] = {};
+    }
+    statement_results_hash[result.library_name][result.statement_name] = result;
+  });
+  return statement_results_hash;
+};
+
 module.exports.IndividualResultSchema = IndividualResultSchema;
 class IndividualResult extends mongoose.Document {
   constructor(object) {

data/app/assets/javascripts/cqm/Measure.js

@@ -64,7 +64,7 @@ const MeasureSchema = new mongoose.Schema(
     // HQMF/Tacoma-specific Measure-logic related data
     population_criteria: Mixed,
     source_data_criteria: [],
-    measure_period: Interval,
+    measure_period: Mixed,
     measure_attributes: [],
 
     population_sets: [PopulationSetSchema],

data/app/assets/javascripts/cqm/Provider.js

@@ -1,5 +1,4 @@
 const mongoose = require('mongoose/browser');
-const Id = require('../Id');
 
 const [Schema, String, Boolean] = [
   mongoose.Schema,
@@ -31,7 +30,6 @@ const ProviderSchema = new Schema({
   title: String,
   addresses: [AddressSchema],
   telecoms: [TelecomSchema],
-  ids: [Id.IdSchema],
 
 }, { id: false });
 

data/app/assets/javascripts/cqm/StatementResult.js

@@ -0,0 +1,41 @@
+const mongoose = require('mongoose/browser');
+
+const [String, Mixed] = [
+  mongoose.Schema.Types.String,
+  mongoose.Schema.Types.Mixed,
+];
+
+const StatementResultSchema = mongoose.Schema({
+  // Library the statement this result is for is in
+  library_name: String,
+  // Statement this result is for is in
+  statement_name: String,
+  // Result, processed for display, of the statement this result is for
+  pretty: String,
+  // Final, processed result of raw calculation
+  final: String,
+  // Raw result of clause calculation
+  raw: Mixed,
+  /*
+   * 'NA' - Not applicable. This statement is not relevant to any population calculation in this population_set. Common
+   *   for unused library statements or statements only used for other population sets.
+   *
+   * 'FALSE' - This statement is not relevant to any of this patient's population inclusion calculations.
+   *
+   * 'TRUE' - This statement is relevant for one or more of the population inclusion calculations.
+    */
+  relevance: {
+    type: String,
+    enum: ['NA', 'TRUE', 'FALSE'],
+    default: 'NA',
+  },
+});
+
+
+module.exports.StatementResultSchema = StatementResultSchema;
+class StatementResult extends mongoose.Document {
+  constructor(object) {
+    super(object, StatementResultSchema);
+  }
+}
+module.exports.StatementResult = StatementResult;