hqmf2js 1.3.0 → 1.4.0

data/app/assets/javascripts/logging_utils.js.coffee

@@ -9,7 +9,9 @@ class @Logger
     if @enable_rationale and result? and typeof(result.isTrue) == 'function'
       if result.isTrue() and result.length
         json_results = _.map(result,(item) -> {id: item.id, json: item.json})
-        @rationale[id] = {results: json_results }
+        if result.specificContext?
+          specific_ids = result.specificContext.flattenToIds()
+        @rationale[id] = {results: json_results, specifics: specific_ids }
       else  
         @rationale[id] = result.isTrue()
 
@@ -132,9 +134,9 @@ class @Logger
     );
     
     # Wrap selected HQMF Util functions
-    hqmf.SpecificsManagerSingleton.prototype.intersectAll = _.wrap(hqmf.SpecificsManagerSingleton.prototype.intersectAll, (func, boolVal, values, negate=false, episodeIndices) ->
-      func = _.bind(func, this, boolVal, values, negate, episodeIndices)
-      result = func(boolVal, values, negate, episodeIndices)
+    hqmf.SpecificsManagerSingleton.prototype.intersectAll = _.wrap(hqmf.SpecificsManagerSingleton.prototype.intersectAll, (func, boolVal, values, negate=false, episodeIndices, options) ->
+      func = _.bind(func, this, boolVal, values, negate, episodeIndices, options)
+      result = func(boolVal, values, negate, episodeIndices, options)
       Logger.info("Intersecting (#{values.length}):")
       for value in values
         Logger.logSpecificContext(value)

data/app/assets/javascripts/patient_api_extension.js.coffee

@@ -54,6 +54,17 @@ hQuery.Encounter::lengthOfStay = (unit) ->
   ivl_ts = this.asIVL_TS()
   ivl_ts.low.difference(ivl_ts.high, unit)
 
+hQuery.Encounter::transferTime = () ->
+  transfer = (@json['transferFrom'] || @json['transferTo'])
+  time = transfer.time if transfer
+  if time
+    hQuery.dateFromUtcSeconds(time)
+  else
+    if @json['transferTo']
+      @endDate()
+    else
+      @startDate()
+
 hQuery.AdministrationTiming::dosesPerDay = () ->
   #figure out the units and value and calculate
   p = this.period()
@@ -64,9 +75,9 @@ hQuery.AdministrationTiming::dosesPerDay = () ->
       1/p.value()
 
 
-hQuery.Fulfillment::daysInRange = (dateRange,doesPerDay) ->
+hQuery.Fulfillment::daysInRange = (dateRange,dose, dosesPerDay) ->
   # this will give us the number of days this fullfilment was for
-  totalDays = this.quantityDispensed().value()/doesPerDay
+  totalDays = this.quantityDispensed().value()/dose/dosesPerDay
   totalDays = 0 if isNaN(totalDays)
   endDate = new Date(this.dispenseDate().getTime() + (totalDays*60*60*24*1000)) 
   high = if dateRange && dateRange.high then dateRange.high.asDate() else endDate
@@ -94,18 +105,39 @@ hQuery.Fulfillment::daysInRange = (dateRange,doesPerDay) ->
 # date range
 hQuery.Medication::fulfillmentTotals = (dateRange)->
   dpd = this.administrationTiming().dosesPerDay()
+  dose = this.dose().scalar
   this.fulfillmentHistory().reduce (t, s) -> 
-    t + s.daysInRange(dateRange,dpd)
+    t + s.daysInRange(dateRange,dose,dpd)
   , 0  
-  
+
+# returns cumulativeMedicationDuration in terms of days
 hQuery.Medication::cumulativeMedicationDuration = (dateRange) ->
-  #assuming that the dose is the same across fills and that fills is  stated in individual 
-  #doses not total amount. Will need to flush this out more at a later point in time. 
-  #Considering that liquid meds are probaly dispensed as total volume ex 325ml with a dose of 
-  #say 25ml per dose.  Will definatley need to revisit this.  
-  this.fulfillmentTotals(dateRange) if this.administrationTiming()
+  #assuming that the dose is the same across fills and that fills is  stated in individual
+  #doses not total amount. Will need to flush this out more at a later point in time.
+  #Considering that liquid meds are probaly dispensed as total volume ex 325ml with a dose of
+  #say 25ml per dose.  Will definatley need to revisit this.
+  if this.administrationTiming() && this.dose() && @json['fulfillmentHistory']
+    this.fulfillmentTotals(dateRange)
+  else if this.administrationTiming() && this.allowedAdministrations()
+    # this happens if we have a Medication, Order.
+    cumulativeMedicationDuration = this.allowedAdministrations() / this.administrationTiming().dosesPerDay()
+    # need to do in case of divide by zero error
+    cumulativeMedicationDuration = 0 if isNaN(cumulativeMedicationDuration)
+    cumulativeMedicationDuration
+
+class hQuery.Reference 
+  constructor: (@json) ->
+  referenced_id: -> @json["referenced_id"]
+  referenced_type: -> @json["reference"]
+  type: ->   @json["type"]
+
 
+hQuery.CodedEntry::references = () ->
+  for ref in (@json["references"] || [])
+    new hQuery.Reference(ref)
 
+hQuery.CodedEntry::referencesByType = (type) -> 
+  e for e in @references() when e.type() == type
 
 hQuery.CodedEntry::respondTo = (functionName) ->
   typeof(@[functionName]) == "function"

data/app/assets/javascripts/specifics.js.coffee

@@ -27,9 +27,22 @@ class hqmf.SpecificsManagerSingleton
       @keyLookup[i] = occurrenceKey.id
       @indexLookup[occurrenceKey.id] = i
       @functionLookup[i] = occurrenceKey.function
-      @typeLookup[occurrenceKey.type] ||= []
-      @typeLookup[occurrenceKey.type].push(i)
-  
+      # LDY 8/25/17
+      # Something changed in the MAT so the "type" is no longer included in the HQMF. The backup
+      # type included too much detail (OccurrenceA_... and OccurrenceB_...), which made the types
+      # appear different for two occurrences of the same type.
+      # The code below ignores "Occ..." strings within the "type". This makes it so the type will
+      # now appear the same where appropriate.
+      # Note: OccurrenceA... is used for regular instances of an occurrence. OccA... is used for
+      # QDM variables.
+      generic_type = occurrenceKey.type
+      match = generic_type.match(/^occ[a-z]*_(.*)/i)
+      if match
+        generic_type = match[1]
+      if generic_type not of @typeLookup
+        @typeLookup[generic_type] = []
+      @typeLookup[generic_type].push(i)
+
   _generateCartisian: (allValues) ->
     _.reduce(allValues, (as, bs) -> 
       product = []
@@ -42,41 +55,34 @@ class hqmf.SpecificsManagerSingleton
   identity: ->
     new hqmf.SpecificOccurrence([new Row(undefined)])
 
-  setIfNull: (events,subsets) ->
-    if (!events.specificContext? || events.length == 0)
-      events.specificContext=hqmf.SpecificsManager.identity()
+  setIfNull: (events) ->
+    # Add specifics if missing, appropriately based on the truthiness
+    if !events.specificContext?
+      if events.isTrue()
+        events.specificContext=hqmf.SpecificsManager.identity()
+      else
+        events.specificContext=hqmf.SpecificsManager.empty()
+    events
       
   getColumnIndex: (occurrenceID) ->
     columnIndex = @indexLookup[occurrenceID]
     if typeof columnIndex == "undefined"
-      throw "Unknown occurrence identifier: "+occurrenceID
+      throw new Error("Unknown occurrence identifier: "+occurrenceID)
     columnIndex
 
   empty: ->
     new hqmf.SpecificOccurrence([])
 
+  # Extract events for leftmost of supplied rows, returning copies with a specificRow attribute set
   extractEventsForLeftMost: (rows) ->
     events = []
     for row in rows
-      events.push(@extractEvent(row.leftMost, row)) if row.leftMost? || row.tempValue?
+      for event in row.leftMostEvents()
+        event = new event.constructor(event.json)
+        event.specificRow = row
+        events.push(event)
     events
-  
-  extractEvents: (key, rows) ->
-    events = []
-    for row in rows
-      events.push(@extractEvent(key, row))
-    events
-    
-  extractEvent: (key, row) ->
-    index = @indexLookup[key]
-    if index?
-      entry = row.values[index]
-    else
-      entry = row.tempValue
-    entry = new hQuery.CodedEntry(entry.json)
-    entry.specificRow = row
-    entry
-    
+
   intersectSpecifics: (nextPopulation, previousPopulation, occurrenceIDs) ->
     # we need to pass the episode indicies all the way down through the interesection to the match function
     # this must be done because we need to ensure that on intersection of populations the * does not allow an episode through
@@ -119,13 +125,13 @@ class hqmf.SpecificsManagerSingleton
   validate: (intersectedPopulation) ->
     intersectedPopulation.isTrue() and intersectedPopulation.specificContext.hasRows()
   
-  intersectAll: (boolVal, values, negate=false, episodeIndices) ->
+  intersectAll: (boolVal, values, negate=false, episodeIndices, options = {}) ->
     result = new hqmf.SpecificOccurrence
     # add identity row
     result.addIdentityRow()
     for value in values
       if value.specificContext?
-        result = result.intersect(value.specificContext, episodeIndices)
+        result = result.intersect(value.specificContext, episodeIndices, options)
     if negate and (!result.hasRows() or result.hasSpecifics())
       result = result.negate()
       result = result.compactReusedEvents()
@@ -153,10 +159,33 @@ class hqmf.SpecificsManagerSingleton
       boolVal = new Boolean(true) if @occurrences.length > 0
     boolVal.specificContext = result
     boolVal
-  
+
+  # Given a set of events with a specificContext, filter the events to include only those
+  # referenced in the specific context
+  filterEventsAgainstSpecifics: (events) ->
+    # If there are no specifics (ie identity) we return them all as-is
+    return events unless events.specificContext.hasSpecifics()
+
+    # Find all the events referenced in the specific context
+    referencedEvents = hqmf.SpecificsManager.extractEventsForLeftMost(events.specificContext.rows)
+    referencedEventIds = _(referencedEvents).pluck('id')
+
+    # Filter original events to only return referenced ones (and ones without an ID, likely dates)
+    result = _(events).select (e) -> !e.id || _(referencedEventIds).contains(e.id)
+
+    # Copy the specifics over and return the result
+    hqmf.SpecificsManager.maintainSpecifics(result, events)
+    return result
+
   # copy the specifics parameters from an existing element onto the new value element
   maintainSpecifics: (newElement, existingElement) ->
-    newElement.specificContext = existingElement.specificContext
+    # We handle a special case: if the existing element is falsy (ie an empty result set), and the new element
+    # is truthy (ie a boolean true), and the specific context is the empty set (no rows), we change it to the
+    # identity; this can happen, for example, if the new element is checking COUNT=0 of the existing element
+    if newElement.isTrue() && existingElement.isFalse() && existingElement.specificContext? && !existingElement.specificContext.hasRows()
+      newElement.specificContext = hqmf.SpecificsManager.identity()
+    else
+      newElement.specificContext = existingElement.specificContext
     newElement.specific_occurrence = existingElement.specific_occurrence
     newElement
 
@@ -194,11 +223,10 @@ class hqmf.SpecificOccurrence
     result
   
   removeDuplicateRows: () ->
-    deduped = new hqmf.SpecificOccurrence
-    for row in @rows
-      # this could potentially be hasRow to dump even more rows.
-      deduped.addRows([row]) if !deduped.hasExactRow(row)
-    deduped
+    # Uniq rows based on each row's string transformation
+    uniqRows = {}
+    uniqRows[row.toHashKey()] = row for row in @rows
+    new hqmf.SpecificOccurrence(_(uniqRows).values())
     
   # Returns a count of unique events for a supplied column index
   uniqueEvents: (columnIndices) ->
@@ -229,21 +257,21 @@ class hqmf.SpecificOccurrence
     value.rows = @rows.concat(other.rows)
     value.removeDuplicateRows()
   
-  intersect: (other, episodeIndices) ->
+  intersect: (other, episodeIndices, options = {}) ->
     value = new hqmf.SpecificOccurrence()
     for leftRow in @rows
       for rightRow in other.rows
-        result = leftRow.intersect(rightRow, episodeIndices)
+        result = leftRow.intersect(rightRow, episodeIndices, options)
         value.rows.push(result) if result?
     value.removeDuplicateRows()
   
   getLeftMost: ->
-    leftMost = undefined
+    specificLeftMost = undefined
     for row in @rows
-      leftMost = row.leftMost unless leftMost?
-      return undefined if leftMost != row.leftMost
-    leftMost
-  
+      specificLeftMost = row.specificLeftMost unless specificLeftMost?
+      return undefined if specificLeftMost != row.specificLeftMost
+    specificLeftMost
+
   negate: ->
     negatedRows = []
     keys = []
@@ -273,6 +301,22 @@ class hqmf.SpecificOccurrence
       newRows.push(myRow) if goodRow
     new hqmf.SpecificOccurrence(newRows)
   
+  # Given a set of events, return new specifics removing any rows that *do not* refer to that set of events
+  filterSpecificsAgainstEvents: (events) ->
+    # If there are no specifics (ie identity) return what we have as-is
+    return this unless @hasSpecifics()
+
+    # Keep and return the rows that refer to any of the provided events (via a leftMost)
+    rowsToKeep = _(@rows).select (row) ->
+      _(row.leftMostEvents()).any (leftMostEvent) ->
+        _(events).any (event) ->
+          # We consider events the same if either 1) both have ids and the ids are the same, or 2) both are
+          # dates, and the dates are the same
+          (event instanceof Date && leftMostEvent instanceof Date && event.getTime() == leftMostEvent.getTime()) ||
+          (event.id? && leftMostEvent.id? && event.id == leftMostEvent.id)
+
+    new hqmf.SpecificOccurrence(rowsToKeep)
+
   hasRow: (row) ->
     found = false
     for myRow in @rows
@@ -297,10 +341,14 @@ class hqmf.SpecificOccurrence
   
   finalizeEvents: (eventsContext, boundsContext) ->
     result = this
-    result = result.intersect(eventsContext) if (eventsContext?)
-    result = result.intersect(boundsContext) if (boundsContext?)
+    result = result.intersect(eventsContext) if eventsContext?
+    result = result.intersect(boundsContext) if boundsContext?
     result.compactReusedEvents()
   
+  # Group rows by everything except the leftmost to apply the subset only to the events from the specific
+  # occurrence context rows on the leftmost column. eg for "MOST RECENT: Occurrence A of Lab Result during
+  # Occurrence A of Encounter" we want to group by the encounter and apply the most recent to the set of
+  # lab results per group (ie encounter)
   group: ->
     groupedRows = {}
     for row in @rows
@@ -308,21 +356,27 @@ class hqmf.SpecificOccurrence
       groupedRows[row.groupKeyForLeftMost()].push(row)
     groupedRows
     
-  COUNT: (range) ->
-    @applyRangeSubset(COUNT, range)
+  COUNT: (range, fields) ->
+    @applyRangeSubset(COUNT, range, fields)
+
+  MIN: (range, fields) ->
+    @applyRangeSubset(MIN, range, fields)
+
+  MAX: (range, fields) ->
+    @applyRangeSubset(MAX, range, fields)
 
-  MIN: (range) ->
-    @applyRangeSubset(MIN, range)
+  SUM: (range, fields) ->
+    @applyRangeSubset(SUM, range, fields)
 
-  MAX: (range) ->
-    @applyRangeSubset(MAX, range)
+  MEDIAN: (range, fields) ->
+    @applyRangeSubset(MEDIAN, range, fields)
     
-  applyRangeSubset: (func, range) ->
+  applyRangeSubset: (func, range, fields) ->
     return this if !@hasSpecifics()
     resultRows = []
     groupedRows = @group()
     for groupKey, group of groupedRows
-      if func(hqmf.SpecificsManager.extractEventsForLeftMost(group), range).isTrue()
+      if func(hqmf.SpecificsManager.extractEventsForLeftMost(group), range, null, fields).isTrue()
         resultRows = resultRows.concat(group)
     new hqmf.SpecificOccurrence(resultRows)
 
@@ -349,7 +403,7 @@ class hqmf.SpecificOccurrence
 
   hasLeftMost: ->
     for row in @rows
-      if row.leftMost? || row.tempValue?
+      if row.specificLeftMost? || row.nonSpecificLeftMost?
         return true
     return false
     
@@ -373,12 +427,11 @@ class hqmf.SpecificOccurrence
 
 class Row
   # {'OccurrenceAEncounter':1, 'OccurrenceBEncounter'2}
-  constructor: (leftMost, occurrences={}) ->
-    throw "left most key must be a string or undefined was: #{leftMost}" if typeof(leftMost) != 'string' and typeof(leftMost) != 'undefined'
+  constructor: (specificLeftMost, occurrences={}) ->
     @length = hqmf.SpecificsManager.occurrences.length
     @values = []
-    @leftMost = leftMost
-    @tempValue = occurrences[undefined]
+    @specificLeftMost = specificLeftMost
+    @nonSpecificLeftMost = occurrences[undefined]
     for i in [0...@length]
       key = hqmf.SpecificsManager.keyLookup[i]
       value = occurrences[key] || hqmf.SpecificsManager.any
@@ -401,14 +454,25 @@ class Row
   equals: (other) ->
     equal = true;
     
-    equal &&= Row.valuesEqual(@tempValue, other.tempValue)
+    equal &&= Row.valuesEqual(@nonSpecificLeftMost, other.nonSpecificLeftMost)
     for value,i in @values
       equal &&= Row.valuesEqual(value, other.values[i])
     equal
 
-  intersect: (other, episodeIndices) ->
-    intersectedRow = new Row(@leftMost, {})
-    intersectedRow.tempValue = @tempValue
+  intersect: (other, episodeIndices, options = {}) ->
+
+    # When we're calculating an actual intersection, where we're returning a set of events, we want to make sure that rows that reference
+    # disjoint expressions aren't combined; this isn't true if we're calculating a boolean AND, chaining temporal operators, etc
+    if options.considerLeftMost
+      # If rows being intersected have different leftMost values, with neither null, then the rows reference disjoint expressions and can't be intersected
+      return undefined if @specificLeftMost && other.specificLeftMost && !Row.valuesEqual(@specificLeftMost, other.specificLeftMost)
+      return undefined if @nonSpecificLeftMost && other.nonSpecificLeftMost && !Row.valuesEqual(@nonSpecificLeftMost, other.nonSpecificLeftMost)
+      # We can set the result row to leftMost + tempValue of whichever of row has it set, since they'll either be the same or one will be undefined
+      intersectedRow = new Row(@specificLeftMost || other.specificLeftMost, {})
+      intersectedRow.nonSpecificLeftMost = @nonSpecificLeftMost || other.nonSpecificLeftMost
+    else
+      intersectedRow = new Row(@specificLeftMost, {})
+      intersectedRow.nonSpecificLeftMost = @nonSpecificLeftMost
 
     # if all the episodes are any, then they were not referenced by the parent population.  This occurs when an intersection is done 
     # against the identity row.  In this case we want to allow the specific occurrences through.  This happens when we intersect against a measure
@@ -431,16 +495,20 @@ class Row
     return true
 
   groupKeyForLeftMost: ->
-    @groupKey(@leftMost)
-    
-  groupKey: (key=null) ->
+    # Get the key(s) to group by, handling hash of specifics or single specific
+    if _.isObject(@specificLeftMost)
+      @groupKey(_(@specificLeftMost).chain().values().flatten().value())
+    else
+      @groupKey([@specificLeftMost])
+
+  groupKey: (keys) ->
+    keys = [keys] if _.isString(keys)
     keyForGroup = ''
     for i in [0...@length]
-      value = hqmf.SpecificsManager.any
-      value = @values[i].id if @values[i] != hqmf.SpecificsManager.any 
-      if hqmf.SpecificsManager.keyLookup[i] == key
+      if _(keys).include(hqmf.SpecificsManager.keyLookup[i])
         keyForGroup += "X_"
       else
+        value = if @values[i] != hqmf.SpecificsManager.any then @values[i].id else hqmf.SpecificsManager.any
         keyForGroup += "#{value}_"
     keyForGroup
     
@@ -481,8 +549,16 @@ class Row
         for matchKey in matchKeys
           occurrences = {}
           occurrences[entryKey] = entry
-          occurrences[matchKey] = match
+          occurrences[matchKey] = match if matchKey? # We don't want to track RHS unless it's a specific occurrence
           rows.push(new Row(entryKey, occurrences))
+      else
+        # Handle case where the match is not a specific occurrence (may have specific occurrences on the RHS)
+        nonSpecificLeftMostRows = _(matches.specificContext.rows).select (r) -> r.nonSpecificLeftMost?.id == match.id
+        entryOccurrences = {}
+        entryOccurrences[entryKey] = entry
+        for nonSpecificLeftMostRow in nonSpecificLeftMostRows
+          result = nonSpecificLeftMostRow.intersect(new Row(entryKey, entryOccurrences))
+          rows.push(result) if result?
     rows
     
   # build specific for a given entry (there are no temporal references)
@@ -503,7 +579,26 @@ class Row
         result.push(value.id)
     result
 
-  
+  toHashKey: ->
+    @flattenToIds().join(",") + ",#{@specificLeftMost}" + ",#{@nonSpecificLeftMost?.id}"
+
+  # If the row references a leftmost, either specific or not, return the event(s)
+  # (because a UNION can place multiple events in the specific leftMost, this can be > 1)
+  leftMostEvents: ->
+    if @nonSpecificLeftMost?
+      return [@nonSpecificLeftMost]
+    if @specificLeftMost? && _.isString(@specificLeftMost)
+      specificIndex = hqmf.SpecificsManager.getColumnIndex(@specificLeftMost)
+      return [@values[specificIndex]] if @values[specificIndex]? && @values[specificIndex] != hqmf.SpecificsManager.any
+    if @specificLeftMost? && _.isObject(@specificLeftMost)
+      events = []
+      for id, occurrences of @specificLeftMost
+        for occurrence in _.uniq(occurrences)
+          specificIndex = hqmf.SpecificsManager.getColumnIndex(occurrence)
+          events.push(@values[specificIndex]) if @values[specificIndex]? && @values[specificIndex] != hqmf.SpecificsManager.any
+      return events
+    return []
+
 @Row = Row
   
 ###
@@ -559,4 +654,3 @@ hQuery.CodedEntryList::match = _.wrap(hQuery.CodedEntryList::match, (func, codeS
   result.specific_occurrence = occurrence
   return result;
 );
-