cqm-models 1.0.3 → 1.1.1.0

data/app/assets/javascripts/ValueSet.js

@@ -1,30 +0,0 @@
-const mongoose = require('mongoose');
-const Concept = require('./Concept.js');
-
-const [String, Mixed, ObjectId] = [
-  mongoose.Schema.Types.String,
-  mongoose.Schema.Types.Mixed,
-  mongoose.Schema.Types.ObjectId,
-];
-
-const ValueSetSchema = mongoose.Schema(
-  {
-    oid: String,
-    display_name: String,
-    version: String,
-    categories: Mixed,
-
-    concepts: [Concept.ConceptSchema],
-
-    user: { type: ObjectId, ref: 'User', index: true }, // Bonnie-specific
-    bundle: { type: ObjectId, ref: 'Bundle' }, // Cypress-specific
-    measures: [{ type: ObjectId, ref: 'Measure' }],
-  },
-  // Options
-  {
-    timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' },
-  }
-);
-
-module.exports.ValueSetSchema = ValueSetSchema;
-module.exports.ValueSet = mongoose.model('value_set', ValueSetSchema);

data/app/models/qdm/tacoma/measure.rb

@@ -1,174 +0,0 @@
-module QDM
-  # Measure contains the information necessary to represent the CQL version of a Clinical Quality Measure,
-  # As needed by the Bonnie & Cypress applications
-  class Measure
-    include Mongoid::Document
-    include Mongoid::Timestamps
-
-    DEFAULT_EFFECTIVE_DATE = Time.gm(2012, 12, 31, 23, 59).to_i
-    MP_START_DATE = Time.gm(2012, 1, 1, 0, 0).to_i
-    TYPES = %w[ep eh].freeze
-
-    IPP = 'IPP'.freeze
-    DENOM = 'DENOM'.freeze
-    NUMER = 'NUMER'.freeze
-    NUMEX = 'NUMEX'.freeze
-    DENEXCEP = 'DENEXCEP'.freeze
-    DENEX = 'DENEX'.freeze
-    MSRPOPL = 'MSRPOPL'.freeze
-    OBSERV = 'OBSERV'.freeze
-    MSRPOPLEX = 'MSRPOPLEX'.freeze
-
-    STRAT = 'STRAT'.freeze
-
-    ALL_POPULATION_CODES = [STRAT, IPP, DENOM, DENEX, NUMER, NUMEX, DENEXCEP, MSRPOPL, OBSERV, MSRPOPLEX].freeze
-
-    CQL_SKIP_STATEMENTS = ['SDE Ethnicity', 'SDE Payer', 'SDE Race', 'SDE Sex'].freeze
-
-    # ID/other measure information
-    field :id, type: String
-    field :measure_id, type: String
-    field :hqmf_id, type: String
-    field :hqmf_set_id, type: String
-    field :hqmf_version_number, type: Integer
-    field :cms_id, type: String
-    field :title, type: String, default: ''
-    field :description, type: String, default: ''
-    field :type, type: String
-    field :category, type: String, default: 'uncategorized'
-
-    # Measure type variables
-    field :episode_of_care, type: Boolean
-    field :continuous_variable, type: Boolean
-    field :episode_ids, type: Array
-
-    # Publishing data (used by Bonnie)
-    field :published, type: Boolean
-    field :publish_date, type: Date
-    field :version, type: Integer
-
-    # ELM/CQL Measure-logic related data
-    field :elm_annotations, type: Hash
-    field :cql, type: Array
-    field :elm, type: Array
-    field :main_cql_library, type: String
-    field :cql_statement_dependencies, type: Hash
-
-    # HQMF/Tacoma-specific Measure-logic related data
-    field :population_criteria, type: Hash
-    field :data_criteria, type: Hash
-    field :source_data_criteria, type: Hash
-    field :measure_period, type: Hash
-    field :measure_attributes, type: Array
-    field :populations, type: Array
-    field :populations_cql_map, type: Hash
-    field :observations, type: Array
-    # TODO: Depending on how we restructure the Measure/Population object, may be deleted in the future
-    field :population_ids, type: Hash
-
-    field :value_set_oids, type: Array, default: []
-    field :value_set_oid_version_objects, type: Array, default: []
-
-    field :complexity, type: Hash
-
-    # Relations to other model classes
-    belongs_to :user
-    belongs_to :bundle, class_name: 'HealthDataStandards::CQM::Bundle'
-    has_and_belongs_to_many :patients, inverse_of: nil
-    has_one :package, class_name: 'CqlMeasurePackage', inverse_of: :measure, dependent: :destroy
-
-    scope :by_measure_id, ->(id) { where('measure_id' => id) }
-    scope :by_type, ->(type) { where('type' => type) }
-    scope :by_user, ->(user) { where user_id: user.id }
-
-    index 'user_id' => 1
-    # Find the measures matching a patient
-    def self.for_patient(record)
-      where user_id: record.user_id, hqmf_set_id: { '$in' => record.measure_ids }
-    end
-
-    def value_sets
-      options = { oid: value_set_oids }
-      options[:user_id] = user.id if user?
-      @value_sets ||= HealthDataStandards::SVS::ValueSet.in(options)
-      @value_sets
-    end
-
-    # Returns the hqmf-parser's ruby implementation of an HQMF document.
-    # Rebuild from population_criteria, data_criteria, and measure_period JSON
-    def as_hqmf_model
-      json = {
-        'id' => measure_id,
-        'title' => title,
-        'description' => description,
-        'population_criteria' => population_criteria,
-        'data_criteria' => data_criteria,
-        'source_data_criteria' => source_data_criteria,
-        'measure_period' => measure_period,
-        'attributes' => measure_attributes,
-        'populations' => populations,
-        'hqmf_id' => hqmf_id,
-        'hqmf_set_id' => hqmf_set_id,
-        'hqmf_version_number' => hqmf_version_number,
-        'cms_id' => cms_id
-      }
-      HQMF::Document.from_json(json)
-    end
-
-    def all_data_criteria
-      as_hqmf_model.all_data_criteria
-    end
-
-    # Note whether or not the measure is a continuous variable measure.
-    before_save :set_continuous_variable
-    def set_continuous_variable
-      # The return value of this function is not related to whether or not this
-      # measure is a CV measure. The true return value ensures false is not
-      # accidentally returned here, which would cause the chain of 'before_*' to
-      # stop executing.
-      self.continuous_variable = populations.map(&:keys).flatten.uniq.include? HQMF::PopulationCriteria::MSRPOPL
-      true
-    end
-
-    # When saving calculate the cyclomatic complexity of the measure
-    # TODO: Do we want to consider a measure other than "cyclomatic complexity" for CQL?
-    # TODO: THIS IS NOT CYCLOMATIC COMPLEXITY, ALL MULTIPLE ELEMENT EXPRESSIONS GET COUNTED AS HIGHER COMPLEXITY, NOT JUST LOGICAL
-    before_save :calculate_complexity
-    def calculate_complexity
-      # We calculate the complexity for each statement, and (at least for now) store the result in the same way
-      # we store the complexity for QDM variables
-      # TODO: consider whether this is too much of a force fit
-      self.complexity = { variables: [] }
-      # Recursively look through an expression to count the logical branches
-      def count_expression_logical_branches(expression)
-        case expression
-        when nil
-          0
-        when Array
-          expression.map { |exp| count_expression_logical_branches(exp) }.sum
-        when Hash
-          case expression['type']
-          when 'And', 'Or', 'Not'
-            count_expression_logical_branches(expression['operand'])
-          when 'Query'
-            # TODO: Do we need to look into the source side of the query? Can there be logical operators there?
-            count_expression_logical_branches(expression['where']) + count_expression_logical_branches(expression['relationship'])
-          else
-            1
-          end
-        else
-          0
-        end
-      end
-
-      # Determine the complexity of each statement
-      elm.each do |elm|
-        next unless (statements = elm.try(:[], 'library').try(:[], 'statements').try(:[], 'def'))
-        statements.each do |statement|
-          complexity[:variables] << { name: statement['name'], complexity: count_expression_logical_branches(statement['expression']) }
-        end
-      end
-      complexity
-    end
-  end
-end

data/app/models/qdm/tacoma/valueset.rb

@@ -1,68 +0,0 @@
-module QDM
-  # ValueSet represents a collection of Concepts, used by the Measures to specify a set of codes for a particular topic
-  class ValueSet
-    include Mongoid::Document
-    field :oid, type: String
-    field :display_name, type: String
-    field :version, type: String
-    field :user_id, type: String # Eventually we need to delete this from bundles when exporting
-    field :categories, type: Hash
-
-    index(oid: 1)
-    embeds_many :concepts
-    index 'concepts.code' => 1
-    index 'concepts.code_system' => 1
-    index 'concepts.code_system_name' => 1
-    index 'bundle_id' => 1
-    scope :by_oid, ->(oid) { where(oid: oid) }
-
-    # Provides an Array of Hashes. Each code system gets its own Hash
-    # The hash has a key of "set" for the code system name and "values"
-    # for the actual code list
-    def code_set_map
-      codes = []
-      concept_pairs = concepts.each_with_object({}) do |concept, memo|
-        memo[concept.code_system_name] ||= []
-        memo[concept.code_system_name] << concept.code
-      end
-      concept_pairs.each_pair do |code_set, code_list|
-        codes << { 'set' => code_set, 'values' => code_list }
-      end
-
-      codes
-    end
-
-    def self.load_from_xml(doc)
-      doc.root.add_namespace_definition('vs', 'urn:ihe:iti:svs:2008')
-      vs_element = doc.at_xpath('/vs:RetrieveValueSetResponse/vs:ValueSet|/vs:RetrieveMultipleValueSetsResponse/vs:DescribedValueSet')
-      return unless vs_element
-      vs = ValueSet.new(oid: vs_element['ID'], display_name: vs_element['displayName'], version: vs_element['version'])
-      vs.concepts = extract_concepts(vs_element)
-      vs.categories = extract_categories(vs_element)
-      vs
-    end
-
-    def self.extract_concepts(vs_element)
-      vs_element.xpath('//vs:Concept').collect do |con|
-        code_system_name = HealthDataStandards::Util::CodeSystemHelper::CODE_SYSTEMS[con['codeSystem']] || con['codeSystemName']
-        Concept.new(code: con['code'],
-                    code_system_name: code_system_name,
-                    code_system_version: con['codeSystemVersion'],
-                    display_name: con['displayName'], code_system: con['codeSystem'])
-      end
-    end
-
-    def self.extract_categories(vs_element)
-      category_hash = Hash.new { |h, k| h[k] = [] }
-      groups_with_categories = vs_element.xpath("//vs:Group/@ID[../@displayName='CATEGORY']")
-      groups_with_categories.each do |group_number|
-        measure = vs_element.xpath("//vs:Group[@displayName='CMS eMeasure ID' and @ID='#{group_number}']/vs:Keyword").text
-        categories_for_group = vs_element.xpath("//vs:Group[@displayName='CATEGORY' and @ID='#{group_number}']/vs:Keyword")
-        categories_for_group.each do |category|
-          category_hash[measure] << category.text
-        end
-      end
-      !category_hash.empty? ? category_hash : nil
-    end
-  end
-end