hqmf2js 1.0.0

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

@@ -0,0 +1,150 @@
+class @Logger
+  @logger: []
+  @info: (string) ->
+    @logger.push("#{Logger.indent()}#{string}")
+  @enabled: true
+  @initialized: false
+  @indentCount = 0
+  @indent: ->
+    indent = ''
+    (indent+=' ' for num in [0..@indentCount*8])
+    indent
+  @stringify: (object) ->
+    if object and !_.isUndefined(object) and !_.isUndefined(object.length)
+      "#{object.length} entries" 
+    else
+      "#{object}"
+  @asBoolean: (object) ->
+    if object and !_.isUndefined(object) and !_.isUndefined(object.length)
+      object.length>0 
+    else
+      object
+  @toJson: (value) ->
+    if (typeof(tojson) == 'function')
+      tojson(value)
+    else
+      JSON.stringify(value)
+  @classNameFor: (object) ->
+    funcNameRegex = ///function (.+)\(///;
+    results = funcNameRegex.exec(object.constructor.toString());
+    if (results and results.length > 1)
+      results[1]
+    else
+      ""
+  @codedValuesAsString: (codedValues) ->
+    "["+_.reduce(codedValues, (memo, entry) -> 
+      memo.push("#{entry.codeSystemName()}:#{entry.code()}");
+      memo
+    , []).join(',')+"]"
+    
+
+@enableMeasureLogging = (hqmfjs) ->
+  _.each(_.functions(hqmfjs), (method) ->
+    hqmfjs[method] = _.wrap(hqmfjs[method], (func, patient) ->
+      Logger.info("#{method}:")
+      Logger.indentCount++
+      result = func(patient)
+      Logger.indentCount--
+      Logger.info("#{method} -> #{Logger.asBoolean(result)}")
+      return result;
+    );
+  );
+
+@enableLogging =->
+  if (!Logger.initialized)
+    Logger.initialized=true
+    
+    _.each(_.functions(hQuery.Patient.prototype), (method) ->
+      if (hQuery.Patient.prototype[method].length == 0)
+        hQuery.Patient.prototype[method] = _.wrap(hQuery.Patient.prototype[method], (func) ->
+          Logger.info("called patient.#{method}():")
+          func = _.bind(func, this)
+          result = func()
+          Logger.info("patient.#{method}() -> #{Logger.stringify(result)}")
+          return result;);
+      else
+        hQuery.Patient.prototype[method] = _.wrap(hQuery.Patient.prototype[method], (func) ->
+          args = Array.prototype.slice.call(arguments,1)
+          Logger.info("called patient.#{method}(#{args}):")
+          result = func.apply(this, args)
+          Logger.info("patient.#{method}(#{args}) -> #{Logger.stringify(result)}")
+          return result;);
+        
+    );
+    
+    hQuery.CodedEntryList.prototype.match = _.wrap(hQuery.CodedEntryList.prototype.match, (func, codeSet, start, end) ->
+      
+      # if (codeSet)
+      #   Logger.info("matching: codeSets(#{_.keys(codeSet).join(",")}), #{start}, #{end}")
+      # else
+      #   Logger.info("matching: WARNING: CODE SETS ARE NULL, #{start}, #{end}")
+        
+      func = _.bind(func, this, codeSet,start,end)
+      result = func(codeSet,start,end)
+      Logger.info("matched -> #{Logger.stringify(result)}")
+      return result;
+    );
+    
+    # hQuery.CodedEntry.prototype.includesCodeFrom = _.wrap(hQuery.CodedEntry.prototype.includesCodeFrom, (func, codeSet) ->
+    #   func = _.bind(func, this, codeSet)
+    #   result = func(codeSet)
+    #   matchText = "--- noMatch"
+    #   matchText = "+++ validMatch" if result
+    #   
+    #   Logger.info("#{matchText}: -> #{Logger.classNameFor(this)}:#{this.freeTextType()}:#{this.date()}:#{Logger.codedValuesAsString(this.type())}")
+    #   
+    #   return result;
+    # );
+    
+    @getCodes = _.wrap(@getCodes, (func, oid) -> 
+      codes = func(oid)
+      Logger.info("accessed codes: #{oid}")
+      codes
+      )
+  
+    @atLeastOneTrue = _.wrap(@atLeastOneTrue, (func) -> 
+      args = Array.prototype.slice.call(arguments,1)
+      Logger.info("called atLeastOneTrue(#{args}):")
+      Logger.indentCount++
+      result = func.apply(this, args)
+      Logger.indentCount--
+      Logger.info("atLeastOneTrue -> #{result}")
+      result
+    )
+    
+    @allTrue = _.wrap(@allTrue, (func) -> 
+      args = Array.prototype.slice.call(arguments,1)
+      Logger.info("called allTrue(#{args}):")
+      Logger.indentCount++
+      result = func.apply(this, args)
+      Logger.indentCount--
+      Logger.info("allTrue -> #{result}")
+      result
+    )
+
+    @allFalse = _.wrap(@allFalse, (func) -> 
+      args = Array.prototype.slice.call(arguments,1)
+      Logger.info("called allFalse(#{args}):")
+      Logger.indentCount++
+      result = func.apply(this, args)
+      Logger.indentCount--
+      Logger.info("allFalse -> #{result}")
+      result
+    )
+
+    @atLeastOneFalse = _.wrap(@atLeastOneFalse, (func) -> 
+      args = Array.prototype.slice.call(arguments,1)
+      Logger.info("called atLeastOneFalse(#{args}):")
+      Logger.indentCount++
+      result = func.apply(this, args)
+      Logger.indentCount--
+      Logger.info("atLeastOneFalse -> #{result}")
+      result
+    )
+    
+    @eventsMatchBounds = _.wrap(@eventsMatchBounds, (func, events, bounds, methodName, range) -> 
+      args = Array.prototype.slice.call(arguments,1)
+      result = func(events, bounds, methodName, range)
+      Logger.info("#{methodName}(Events: #{Logger.stringify(events)}, Bounds: #{Logger.stringify(bounds)}, Range: #{Logger.toJson(range)}) -> #{Logger.stringify(result)}")
+      result
+    )

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

@@ -0,0 +1,36 @@
+hQuery.Patient::procedureResults = -> this.results().concat(this.vitalSigns()).concat(this.procedures())
+hQuery.Patient::allProcedures = -> this.procedures().concat(this.immunizations()).concat(this.medications())
+hQuery.Patient::laboratoryTests = -> this.results().concat(this.vitalSigns())
+hQuery.Patient::allMedications = -> this.medications().concat(this.immunizations())
+hQuery.Patient::allProblems = -> this.conditions().concat(this.socialHistories()).concat(this.procedures())
+hQuery.Patient::allDevices = -> this.conditions().concat(this.procedures()).concat(this.careGoals()).concat(this.medicalEquipment())
+hQuery.Patient::activeDiagnoses = -> this.conditions().concat(this.socialHistories()).withStatuses(['active'])
+hQuery.Patient::inactiveDiagnoses = -> this.conditions().concat(this.socialHistories()).withStatuses(['inactive'])
+hQuery.Patient::resolvedDiagnoses = -> this.conditions().concat(this.socialHistories()).withStatuses(['resolved'])
+hQuery.CodedEntry::asIVL_TS = ->
+  tsLow = new TS()
+  tsLow.date = this.startDate() || this.date() || null
+  tsHigh = new TS()
+  tsHigh.date = this.endDate() || this.date() || null
+  new IVL_TS(tsLow, tsHigh)
+
+hQuery.CodedEntry::respondTo = (functionName) ->
+  typeof(@[functionName]) == "function"
+
+hQuery.CodedEntryList::isTrue = ->
+  @length != 0
+
+hQuery.CodedEntryList::isFalse = ->
+  @length == 0
+
+Array::isTrue = ->
+  @length != 0
+
+Array::isFalse = ->
+  @length == 0
+
+Boolean::isTrue = =>
+  `this == true`
+  
+Boolean::isFalse = =>
+  `this == false`

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

@@ -0,0 +1,462 @@
+
+wrap = (func, wrapper) ->
+  () ->
+    args = [func].concat(Array::slice.call(arguments, 0));
+    wrapper.apply(this, args);
+
+bind = (func, context) ->
+  
+  return Function::bind.apply(func, Array::slice.call(arguments, 1)) if (func.bind == Function::bind && Function::bind)
+  throw new TypeError if (typeof func != "function") 
+  args = Array::slice.call(arguments, 2)
+  return bound = ->
+    ctor = ->
+    return func.apply(context, args.concat(Array::slice.call(arguments))) if (!(this instanceof bound)) 
+    ctor.prototype = func.prototype
+    self = new ctor
+    result = func.apply(self, args.concat(Array::slice.call(arguments)))
+    return result if (Object(result) == result) 
+    self
+
+Array::unique = ->
+  output = {}
+  output[@[key]] = @[key] for key in [0...@length]
+  value for key, value of output
+
+Array::reduce = (accumulator) ->
+  throw new TypeError("Object is null or undefined") if (this==null or this==undefined) 
+  i = 0
+  l = this.length >> 0
+  curr=undefined
+  
+  throw new TypeError("First argument is not callable") if(typeof accumulator != "function")
+  
+  if(arguments.length < 2) 
+    throw new TypeError("Array length is 0 and no second argument") if (l == 0) 
+    curr = this[0]
+    i = 1
+  else
+    curr = arguments[1]
+
+  while (i < l) 
+    curr = accumulator.call(undefined, curr, this[i], i, this) if(`i in this`) 
+    ++i
+    
+  return curr
+  
+
+###
+  {
+    rows: [
+      [1,3,5],
+      [1,7,8],
+    ]
+  }
+###
+class Specifics
+  
+  @OCCURRENCES
+  @KEY_LOOKUP
+  @TYPE_LOOKUP
+  @INITIALIZED: false
+  @PATIENT: null
+  @ANY = '*'
+  
+  @initialize: (patient, hqmfjs, occurrences...)->
+    Specifics.OCCURRENCES = occurrences
+    Specifics.KEY_LOOKUP = {}
+    Specifics.INDEX_LOOKUP = {}
+    Specifics.TYPE_LOOKUP = {}
+    Specifics.FUNCTION_LOOKUP = {}
+    Specifics.PATIENT = patient
+    Specifics.HQMFJS = hqmfjs
+    for occurrenceKey,i in occurrences
+      Specifics.KEY_LOOKUP[i] = occurrenceKey.id
+      Specifics.INDEX_LOOKUP[occurrenceKey.id] = i
+      Specifics.FUNCTION_LOOKUP[i] = occurrenceKey.function
+      Specifics.TYPE_LOOKUP[occurrenceKey.type] ||= []
+      Specifics.TYPE_LOOKUP[occurrenceKey.type].push(i)
+  
+  constructor: (rows=[])->
+    @rows = rows
+  
+  addRows: (rows) ->
+    @rows = @rows.concat(rows)
+    
+  removeDuplicateRows: () ->
+    deduped = new Specifics()
+    for row in @rows
+      # this could potentially be hasRow to dump even more rows.
+      deduped.addRows([row]) if !deduped.hasExactRow(row)
+    deduped
+  
+  hasExactRow: (other) ->
+    for row in @rows
+      return true if row.equals(other)
+    return false
+  
+  union: (other) ->
+    value = new Specifics()
+    value.rows = @rows.concat(other.rows)
+    value.removeDuplicateRows()
+  
+  intersect: (other) ->
+    value = new Specifics()
+    for leftRow in @rows
+      for rightRow in other.rows
+        result = leftRow.intersect(rightRow)
+        value.rows.push(result) if result?
+    value.removeDuplicateRows()
+  
+  getLeftMost: ->
+    leftMost = undefined
+    for row in @rows
+      leftMost = row.leftMost unless leftMost?
+      return undefined if leftMost != row.leftMost
+    leftMost
+  
+  negate: ->
+    negatedRows = []
+    keys = []
+    allValues = []
+    for index in @specificsWithValues()
+      keys.push(Specifics.KEY_LOOKUP[index])
+      allValues.push(Specifics.HQMFJS[Specifics.FUNCTION_LOOKUP[index]](Specifics.PATIENT))
+    cartesian = Specifics._generateCartisian(allValues)
+    for values in cartesian
+      occurrences = {}
+      for key, i in keys
+        occurrences[key] = values[i]
+      row = new Row(@getLeftMost(), occurrences)
+      negatedRows.push(row) if !@hasRow(row)
+    (new Specifics(negatedRows)).compactReusedEvents()
+
+  @_generateCartisian: (allValues) ->
+    Array::reduce.call(allValues, (as, bs) -> 
+      product = []
+      for a in as
+        for b in bs
+          product.push(a.concat(b))
+      product
+    , [[]])
+
+  # removes any rows that have the save value for OccurrenceA and OccurrenceB
+  compactReusedEvents: ->
+    newRows = []
+    for myRow in @rows
+      goodRow = true
+      for type,indexes of Specifics.TYPE_LOOKUP
+        ids = []
+        for index in indexes
+          ids.push(myRow.values[index].id) if myRow.values[index] != Specifics.ANY
+        goodRow &&= ids.length == ids.unique().length
+      newRows.push(myRow) if goodRow
+    new Specifics(newRows)
+  
+  hasRow: (row) ->
+    found = false
+    for myRow in @rows
+      result = myRow.intersect(row)
+      return true if result?
+    return false
+  
+  hasRows: ->
+    @rows.length > 0
+  
+  specificsWithValues: ->
+    foundSpecificIndexes = []
+    for row in @rows
+      foundSpecificIndexes = foundSpecificIndexes.concat(row.specificsWithValues())
+    foundSpecificIndexes.unique()
+  
+  hasSpecifics: ->
+    anyHaveSpecifics = false
+    for row in @rows
+      anyHaveSpecifics ||= row.hasSpecifics()
+    anyHaveSpecifics
+  
+  finalizeEvents: (eventsContext, boundsContext) ->
+    result = this
+    result = result.intersect(eventsContext) if (eventsContext?)
+    result = result.intersect(boundsContext) if (boundsContext?)
+    result.compactReusedEvents()
+  
+  group: ->
+    groupedRows = {}
+    for row in @rows
+      groupedRows[row.groupKeyForLeftMost()] ||= []
+      groupedRows[row.groupKeyForLeftMost()].push(row)
+    groupedRows
+    
+  COUNT: (range) ->
+    @applyRangeSubset(COUNT, range)
+
+  MIN: (range) ->
+    @applyRangeSubset(MIN, range)
+
+  MAX: (range) ->
+    @applyRangeSubset(MAX, range)
+    
+  applyRangeSubset: (func, range) ->
+    return this if !@hasSpecifics()
+    resultRows = []
+    groupedRows = @group()
+    for groupKey, group of groupedRows
+      if func(Specifics.extractEventsForLeftMost(group), range).isTrue()
+        resultRows = resultRows.concat(group)
+    new Specifics(resultRows)
+
+  FIRST: ->
+    @applySubset(FIRST)
+
+  SECOND: ->
+    @applySubset(SECOND)
+
+  THIRD: ->
+    @applySubset(THIRD)
+
+  FOURTH: ->
+    @applySubset(FOURTH)
+
+  FIFTH: ->
+    @applySubset(FIFTH)
+
+  LAST: ->
+    @applySubset(LAST)
+
+  RECENT: ->
+    @applySubset(RECENT)
+    
+  applySubset: (func) ->
+    return this if !@hasSpecifics()
+    resultRows = []
+    groupedRows = @group()
+    for groupKey, group of groupedRows
+      entries = func(Specifics.extractEventsForLeftMost(group))
+      if entries.length > 0
+        resultRows.push(entries[0].specificRow)
+    new Specifics(resultRows)
+  
+  addIdentityRow: ->
+    @addRows(Specifics.identity().rows)
+  
+  @identity: ->
+    new Specifics([new Row(undefined)])
+  
+
+  @extractEventsForLeftMost: (rows) ->
+    events = []
+    for row in rows
+      events.push(Specifics.extractEvent(row.leftMost, row))
+    events
+  
+  
+  @extractEvents: (key, rows) ->
+    events = []
+    for row in rows
+      events.push(Specifics.extractEvent(key, row))
+    events
+    
+  @extractEvent: (key, row) ->
+    index = Specifics.INDEX_LOOKUP[key]
+    if index?
+      entry = row.values[index]
+    else
+      entry = row.tempValue
+    entry = new hQuery.CodedEntry(entry.json)
+    entry.specificRow = row
+    entry
+  
+  @validate: (populations...) ->
+    value = Specifics.intersectAll(new Boolean(populations[0].isTrue()), populations)
+    value.isTrue() and value.specificContext.hasRows()
+  
+  @intersectAll: (boolVal, values, negate=false) ->
+    result = new Specifics()
+    # add identity row
+    result.addIdentityRow()
+    for value in values
+      if value.specificContext?
+        result = result.intersect(value.specificContext)
+    if negate and (!result.hasRows() or result.hasSpecifics())
+      result = result.negate()
+      result = result.compactReusedEvents()
+      # this is a little odd, but it appears when we have a negation with specifics we can ignore the logical result of the negation.
+      # the reason we do this is because we may get too many negated values.  Values that may be culled later via other specific occurrences.  Thus we do not want to return 
+      # false out of a negation because the values we are evaluating as false may be dropped.
+      boolVal = new Boolean(true)
+    boolVal.specificContext = result.compactReusedEvents()
+    boolVal
+
+  @unionAll: (boolVal, values,negate=false) ->
+    result = new Specifics()
+    for value in values
+      if value.specificContext? and (value.isTrue() or negate)
+        result = result.union(value.specificContext) if value.specificContext?
+    
+    if negate and result.hasSpecifics()
+      result = result.negate() 
+      # this is a little odd, but it appears when we have a negation with specifics we can ignore the logical result of the negation.  See comment in intersectAll.
+      boolVal = new Boolean(true)
+    boolVal.specificContext = result
+    boolVal
+  
+  # copy the specifics parameters from an existing element onto the new value element
+  @maintainSpecifics: (newElement, existingElement) ->
+    newElement.specificContext = existingElement.specificContext
+    newElement.specific_occurrence = existingElement.specific_occurrence
+    newElement
+    
+@Specifics = Specifics
+
+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'
+    @length = Specifics.OCCURRENCES.length
+    @values = []
+    @leftMost = leftMost
+    @tempValue = occurrences[undefined]
+    for i in [0...@length]
+      key = Specifics.KEY_LOOKUP[i]
+      value = occurrences[key] || Specifics.ANY
+      @values[i] = value
+
+  hasSpecifics: ->
+    @length = Specifics.OCCURRENCES.length
+    foundSpecific = false
+    for i in [0...@length]
+      return true if @values[i] != Specifics.ANY
+    false
+
+  specificsWithValues: ->
+    @length = Specifics.OCCURRENCES.length
+    foundSpecificIndexes = []
+    for i in [0...@length]
+      foundSpecificIndexes.push(i) if @values[i]? and @values[i] != Specifics.ANY
+    foundSpecificIndexes
+
+  equals: (other) ->
+    equal = true;
+    
+    equal &&= Row.valuesEqual(@tempValue, other.tempValue)
+    for value,i in @values
+      equal &&= Row.valuesEqual(value, other.values[i])
+    equal
+
+  intersect: (other) ->
+    intersectedRow = new Row(@leftMost, {})
+    intersectedRow.tempValue = @tempValue
+    allMatch = true
+    for value,i in @values
+      result = Row.match(value, other.values[i])
+      if result?
+        intersectedRow.values[i] = result 
+      else
+        return undefined
+    intersectedRow
+  
+  groupKeyForLeftMost: ->
+    @groupKey(@leftMost)
+    
+  groupKey: (key=null) ->
+    keyForGroup = ''
+    for i in [0...@length]
+      value = Specifics.ANY
+      value = @values[i].id if @values[i] != Specifics.ANY 
+      if Specifics.KEY_LOOKUP[i] == key
+        keyForGroup += "X_"
+      else
+        keyForGroup += "#{value}_"
+    keyForGroup
+    
+  
+  @match: (left, right) ->
+    return right if left == Specifics.ANY
+    return left if right == Specifics.ANY
+    return left if left.id == right.id
+    return undefined
+
+  @valuesEqual: (left, right) ->
+    return true if !left? and !right?
+    return false if !left?
+    return false if !right?
+    return true if left == Specifics.ANY and right == Specifics.ANY
+    return true if left.id == right.id
+    return false
+  
+  # build specific for an entry given matching rows (with temporal references)
+  @buildRowsForMatching: (entryKey, entry, matchesKey, matches) ->
+    rows = []
+    for match in matches
+      occurrences={}
+      occurrences[entryKey] = entry
+      occurrences[matchesKey] = match
+      rows.push(new Row(entryKey, occurrences))
+    rows
+    
+  # build specific for a given entry (there are no temporal references)
+  @buildForDataCriteria: (entryKey, entries) ->
+    rows = []
+    for entry in entries
+      occurrences={}
+      occurrences[entryKey] = entry
+      rows.push(new Row(entryKey, occurrences))
+    rows
+  
+@Row = Row
+  
+###
+  Wrap methods to maintain specificContext and specific_occurrence
+###
+
+hQuery.CodedEntryList::withStatuses = wrap(hQuery.CodedEntryList::withStatuses, (func, statuses, includeUndefined=true) ->
+  context = this.specificContext
+  occurrence = this.specific_occurrence
+  func = bind(func, this)
+  result = func(statuses,includeUndefined)
+  result.specificContext = context
+  result.specific_occurrence = occurrence
+  return result;
+);
+
+hQuery.CodedEntryList::withNegation = wrap(hQuery.CodedEntryList::withNegation, (func, codeSet) ->
+  context = this.specificContext
+  occurrence = this.specific_occurrence
+  func = bind(func, this)
+  result = func(codeSet)
+  result.specificContext = context
+  result.specific_occurrence = occurrence
+  return result;
+);
+
+hQuery.CodedEntryList::withoutNegation = wrap(hQuery.CodedEntryList::withoutNegation, (func) ->
+  context = this.specificContext
+  occurrence = this.specific_occurrence
+  func = bind(func, this)
+  result = func()
+  result.specificContext = context
+  result.specific_occurrence = occurrence
+  return result;
+);
+
+hQuery.CodedEntryList::concat = wrap(hQuery.CodedEntryList::concat, (func, otherEntries) ->
+  context = this.specificContext
+  occurrence = this.specific_occurrence
+  func = bind(func, this)
+  result = func(otherEntries)
+  result.specificContext = context
+  result.specific_occurrence = occurrence
+  return result;
+);
+
+hQuery.CodedEntryList::match = wrap(hQuery.CodedEntryList::match, (func, codeSet, start, end, includeNegated=false) ->
+  context = this.specificContext
+  occurrence = this.specific_occurrence
+  func = bind(func, this)
+  result = func(codeSet, start, end, includeNegated)
+  result.specificContext = context
+  result.specific_occurrence = occurrence
+  return result;
+);
+

data/bin/hqmf2js.rb

@@ -0,0 +1,25 @@
+#! /usr/bin/env ruby
+require_relative '../lib/hqmf2js'
+
+if ARGV.length != 1 || !File.exists?(ARGV[0])
+  puts "Usage: hqmf2js hqmf_file"
+else
+  hqmf_contents = File.open(ARGV[0]).read
+  gen = HQMF2JS::Generator::JS.new(hqmf_contents)
+  
+  codes = HQMF2JS::Generator::CodesToJson.new(File.expand_path("../../test/fixtures/codes.xml", __FILE__))
+  codes_json = codes.json
+  puts "var OidDictionary = #{codes_json};"
+  
+  ctx = Sprockets::Environment.new(File.expand_path("../..", __FILE__))
+  Tilt::CoffeeScriptTemplate.default_bare = true 
+  ctx.append_path "app/assets/javascripts"
+  hqmf_utils = ctx.find_asset('hqmf_util').to_s
+  puts hqmf_utils
+  
+  puts gen.js_for_data_criteria()
+  puts gen.js_for('IPP')
+  puts gen.js_for('DENOM')
+  puts gen.js_for('NUMER')
+  puts gen.js_for('DENEXCEP')
+end