mCSD Changes plus more

lib/atna-audit.js

@@ -15,7 +15,8 @@ const ATNAAuditConfig = require('./config').getConf('atnaAudit')
 let connDetail = {
   interface: ATNAAuditConfig.interface,
   host: ATNAAuditConfig.host,
-  port: ATNAAuditConfig.port
+  port: ATNAAuditConfig.port,
+  options: {}
 }
 
 if (ATNAAuditConfig.certOptions.key) {
@@ -110,6 +111,47 @@ exports.buildPDQmAuditMsg = (ctx) => {
   return syslog
 }
 
+exports.buildmCSDAuditMsg = (ctx, transaction, actor) => {
+  // event
+  var eventID = new ATNA.construct.Code(110112, 'Query', 'DCM')
+  var typeCode = new ATNA.construct.Code(transaction, 'Mobile Care Services Discovery '+actor+' Query', 'IHE Transactions')
+  var eIdent = new ATNA.construct.EventIdentification(ATNA.constants.EVENT_ACTION_EXECUTE, new Date(), ATNA.constants.OUTCOME_SUCCESS, eventID, typeCode)
+
+  var user = ctx.authenticatedUser.email;
+  // Active Participant - System
+  var sysRoleCode = new ATNA.construct.Code(110153, 'Source', 'DCM')
+  var sysParticipant = new ATNA.construct.ActiveParticipant(user, '', false, ctx.requestorIp, ATNA.constants.NET_AP_TYPE_IP, [sysRoleCode])
+
+  // Active Participant - User
+  var userRoleCodeDef = new ATNA.construct.Code(110152, 'DCM', 'Destination')
+  var userParticipant = new ATNA.construct.ActiveParticipant(user, '', true, null, null, [userRoleCodeDef])
+
+  // Audit Source
+  var sourceTypeCode = new ATNA.construct.Code(ATNA.constants.AUDIT_SRC_TYPE_WEB_SERVER, '', '')
+  var sourceIdent = new ATNA.construct.AuditSourceIdentification(null, ctx.authenticatedUser, sourceTypeCode)
+
+  // Participant Object
+  var objIdTypeCode = new ATNA.construct.Code(transaction, 'Mobile Care Services Discovery '+actor+' Query', 'IHE Transactions')
+  var participantObj = new ATNA.construct.ParticipantObjectIdentification(
+    ctx.fullUrl,
+    ATNA.constants.OBJ_TYPE_SYS_OBJ,
+    ATNA.constants.OBJ_TYPE_CODE_ROLE_QUERY,
+    null,
+    null,
+    objIdTypeCode,
+    null,
+    new Buffer(ctx.fullUrl).toString('base64')
+  )
+
+  var audit = new ATNA.construct.AuditMessage(eIdent, [sysParticipant, userParticipant], [participantObj], [sourceIdent])
+  var xml = audit.toXML()
+
+  const syslog = ATNA.construct.wrapInSyslog(xml)
+
+  return syslog
+}
+
+
 exports.sendAuditEvent = (msg, callback) => {
   if (!ATNAAuditConfig.enabled) {
     return

lib/fhir/common.js

@@ -360,9 +360,16 @@ module.exports = exports = (mongo) => {
           if (entry._mpi) {
             search = entry._mpi.search
           }
+        if ( entry._request.method == 'POST' ) {
+            entry._request.url = entry.resourceType
+        } else {
+            entry._request.url = entry.resourceType+"/"+entry.id
+        }
+
           const ret = {
-            fullUrl: `${config.getConf('server:publicFhirBase')}/${entry.resourceType}/${entry.id}`,
-            resource: entry
+            fullUrl: `${config.getConf('server:publicFhirBase')}/${entry.resourceType}/${entry.id}/_history/${entry.meta.versionId}`,
+            resource: entry,
+            request: entry._request
           }
 
           if (search) {
@@ -543,7 +550,7 @@ module.exports = exports = (mongo) => {
      */
     getPagingParams: (queryParams, callback) => {
       let _getpagesoffset = 0
-      let _count = 10
+      let _count = 100
 
       if (queryParams._getpagesoffset) {
         _getpagesoffset = parseInt(queryParams._getpagesoffset)

lib/fhir/core.js

@@ -7,12 +7,14 @@
  */
 'use strict'
 
+const moment = require('moment')
 const logger = require('winston')
 
 const FhirCommon = require('./common')
 const Authorization = require('../security/authorization')
 const Hooks = require('./hooks')
 const matchingConfig = require('../../config/matching')
+const QueryUtils = require('./query-utils');
 
 const handleErrorAndBadRequest = (err, badRequest, callback) => {
   if (err) {
@@ -30,6 +32,7 @@ const handleErrorAndBadRequest = (err, badRequest, callback) => {
 module.exports = (mongo, modules) => {
   const fhirCommon = FhirCommon(mongo)
   const authorization = Authorization(mongo)
+  const queryUtils = QueryUtils(mongo)
   const hooks = Hooks()
 
   return {
@@ -321,6 +324,133 @@ module.exports = (mongo, modules) => {
       })
     },
 
+    /**
+     * History for a resource. The 'query' field must be specified in the RequestContext parameter.
+     *
+     * @param {RequestContext} ctx
+     * @param {String} resourceType The type of FHIR resource
+     * @param {CoreCallback} callback
+     */
+    history: (ctx, resourceType, callback) => {
+      authorization.authorize('history', ctx, resourceType, (err, badRequest) => {
+        if (err || badRequest) {
+          return handleErrorAndBadRequest(err, badRequest, callback)
+        }
+
+        const fhirModule = modules[resourceType]
+        hooks.executeBeforeHooks('history', fhirModule, ctx, resourceType, (err, badRequest) => {
+          if (err || badRequest) {
+            return handleErrorAndBadRequest(err, badRequest, callback)
+          }
+
+          mongo.getDB((err, db) => {
+            if (err) {
+              return callback(err)
+            }
+
+            /* This doesn't work for deletes but saving in case needed later.
+            let query = [ { $lookup : { from : resourceType+'_history', localField: "id", foreignField: "id", as: 'history' } }, 
+              { $lookup : { from: resourceType, localField: 'id', foreignField: 'id', as : 'top' } }, 
+              { $project : { allHist :{ $setUnion : ["$top","$history"] } } }, 
+              { $unwind : "$allHist" }, 
+              {$replaceRoot: {newRoot:"$allHist"}} ]
+            */
+            let query = [
+              { $limit: 1 },
+              { $lookup: { from: resourceType, pipeline:[], as: "top" } }, 
+              { $lookup: { from: resourceType+"_history", pipeline: [], as: "history" } },
+              { $project: { all: { $setUnion: [ "$top", "$history" ] } } },
+              { $unwind: "$all" }, 
+              { $replaceRoot: { newRoot: "$all" } }
+              ]
+
+            if ( ctx.query._since ) {
+                const matchClause = {$match: queryUtils.dateToMongoClause('meta.lastUpdated', 'ge'+ctx.query._since) }
+                query[1].$lookup.pipeline.push( matchClause )
+                query[2].$lookup.pipeline.push( matchClause )
+            }
+
+            let cntQuery = query.slice(0,query.length)
+            cntQuery.push( {$count: 'total'} )
+
+            query.push( {$sort: {'meta.lastUpdated':-1} } )
+
+
+            mongo.util.debugLog(resourceType, 'history', query)
+
+            fhirCommon.getPagingParams(ctx.query, (err, badRequest, _getpagesoffset, _count) => {
+              if (err || badRequest) {
+                return handleErrorAndBadRequest(err, badRequest, callback)
+              }
+
+              const c = db.collection(resourceType)
+              c.aggregate(cntQuery, (err, total) => {
+                if (err) {
+                  return callback(err)
+                }
+                if ( total.length == 0 ) {
+                    const response = fhirCommon.bundleResults('history', [], 0, ctx.url)
+                    hooks.executeAfterHooks('history', fhirModule, ctx, resourceType, response, (err, badRequest, results) => {
+                      if (err || badRequest) {
+                        return handleErrorAndBadRequest(err, badRequest, callback)
+                      }
+
+                      // format the updated entry array for the response
+                      if (results && results.entry) {
+                        results.entry.forEach((resource) => {
+                          fhirCommon.formatResource(resource.resource)
+                        })
+                      }
+
+                      callback(null, { httpStatus: 200, resource: results })
+                    })
+                 } else {
+                  total = total[0].total
+
+
+                  c.aggregate(query).skip(_getpagesoffset).limit(_count).toArray((err, results) => {
+                    if (err) {
+                      return callback(err)
+                    }
+
+
+                    const response = fhirCommon.bundleResults('history', results, total, ctx.url)
+                    if (_getpagesoffset + _count < total) {
+                      fhirCommon.addBundleLinkNext(response, ctx.url, _getpagesoffset + _count, _count)
+                    }
+
+                    hooks.executeAfterHooks('history', fhirModule, ctx, resourceType, response, (err, badRequest, results) => {
+                      if (err || badRequest) {
+                        return handleErrorAndBadRequest(err, badRequest, callback)
+                      }
+
+                      // format the updated entry array for the response
+                      if (results && results.entry) {
+                        results.entry.forEach((resource) => {
+                          fhirCommon.formatResource(resource.resource)
+                        })
+                      }
+
+                      callback(null, { httpStatus: 200, resource: results })
+                    })
+
+
+                  })// find
+
+                }
+
+
+              })
+            })
+
+
+          }) //mongo.getdb.
+        })
+      })
+    },
+
+
+
     /**
      * Create a new resource.
      *
@@ -342,10 +472,13 @@ module.exports = (mongo, modules) => {
         }
 
         const fhirModule = modules[resourceType]
-        hooks.executeBeforeHooks('create', fhirModule, ctx, resourceType, resource, (err, badRequest) => {
+        hooks.executeBeforeHooks('create', fhirModule, ctx, resourceType, resource, (err, badRequest, newResource) => {
           if (err || badRequest) {
             return handleErrorAndBadRequest(err, badRequest, callback)
           }
+          if ( newResource ) {
+              resource = newResource;
+          }
 
           if (!resource.resourceType || resource.resourceType !== resourceType) {
             return callback(null, fhirCommon.buildHTTPOutcome(400, 'error', 'invalid', 'Invalid resource type'))
@@ -406,10 +539,13 @@ module.exports = (mongo, modules) => {
         }
 
         const fhirModule = modules[resourceType]
-        hooks.executeBeforeHooks('update', fhirModule, ctx, resourceType, resource, (err, badRequest) => {
+        hooks.executeBeforeHooks('update', fhirModule, ctx, resourceType, resource, (err, badRequest, newResource) => {
           if (err || badRequest) {
             return handleErrorAndBadRequest(err, badRequest, callback)
           }
+          if ( newResource ) {
+              resource = newResource;
+          }
           if (!resource.resourceType || resource.resourceType !== resourceType) {
             return callback(null, fhirCommon.buildHTTPOutcome(400, 'error', 'invalid', 'Invalid resource type'))
           }
@@ -430,7 +566,7 @@ module.exports = (mongo, modules) => {
             resource.meta.versionId = fhirCommon.util.generateID()
 
             const options = {
-              upsert: false, // TODO OHIE-168
+              upsert: true, // TODO OHIE-168
               returnOriginal: true
             }
 
@@ -441,16 +577,6 @@ module.exports = (mongo, modules) => {
               }
 
               if (!result.value) {
-                return callback(null, fhirCommon.buildHTTPOutcome(404, 'information', 'not-found', 'Not found'))
-              }
-
-              delete result.value._id
-
-              const cHistory = db.collection(`${resourceType}_history`)
-              cHistory.insert(result.value, (err) => {
-                if (err) {
-                  return callback(err)
-                }
                 hooks.executeAfterHooks('update', fhirModule, ctx, resourceType, resource, (err, badRequest) => {
                   if (err || badRequest) {
                     return handleErrorAndBadRequest(err, badRequest, callback)
@@ -459,7 +585,26 @@ module.exports = (mongo, modules) => {
                   const location = `/fhir/${resourceType}/${id}/_history/${resource.meta.versionId}`
                   callback(null, { httpStatus: 200, location: location, id: id })
                 })
-              })
+                //return callback(null, fhirCommon.buildHTTPOutcome(404, 'information', 'not-found', 'Not found'))
+              } else {
+
+                delete result.value._id
+
+                const cHistory = db.collection(`${resourceType}_history`)
+                cHistory.insert(result.value, (err) => {
+                  if (err) {
+                    return callback(err)
+                  }
+                  hooks.executeAfterHooks('update', fhirModule, ctx, resourceType, resource, (err, badRequest) => {
+                    if (err || badRequest) {
+                      return handleErrorAndBadRequest(err, badRequest, callback)
+                    }
+
+                    const location = `/fhir/${resourceType}/${id}/_history/${resource.meta.versionId}`
+                    callback(null, { httpStatus: 200, location: location, id: id })
+                  })
+                })
+              }
             })
           })
         })
@@ -510,13 +655,33 @@ module.exports = (mongo, modules) => {
                   if (err) {
                     return callback(err)
                   }
-                  hooks.executeAfterHooks('delete', fhirModule, ctx, resourceType, historyDoc, (err, badRequest) => {
-                    if (err || badRequest) {
-                      return handleErrorAndBadRequest(err, badRequest, callback)
+
+                  // Also need to add a deleted record to the history.
+                  const dateFormat = 'YYYY-MM-DDTHH:mm:ss.SSSZ'
+                  const deleteDoc = {
+                    id: historyDoc.id,
+                    resourceType: historyDoc.resourceType,
+                    _request: { method: "DELETE" },
+                    meta: { lastUpdated: moment().format(dateFormat) }
+                  }
+
+                  cHistory.insert(deleteDoc, (err) => {
+                    if (err) {
+                      return callback(err)
                     }
 
-                    callback(null, { httpStatus: 204, id: id })
+                    hooks.executeAfterHooks('delete', fhirModule, ctx, resourceType, historyDoc, (err, badRequest) => {
+                      if (err || badRequest) {
+                        return handleErrorAndBadRequest(err, badRequest, callback)
+                      }
+
+                      callback(null, { httpStatus: 204, id: id })
+                    })
+
                   })
+
+
+
                 })
               } else {
                 cHistory.remove({ id: id }, (err) => {

lib/fhir/module-loader.js

@@ -25,7 +25,7 @@ function getLoadedModule (resourceType) {
 module.exports = exports = (mongo) => {
   return {
     loadModules: () => {
-      fs.readdirSync(path.resolve(`${global.appRoot}/lib/fhir/resources`)).forEach((file) => {
+      fs.readdirSync(path.resolve(`${global.appRoot}/lib/fhir/resources`)).filter(function(file) { return path.extname(file) === '.js' } ).forEach((file) => {
         let module = require(`./resources/${file}`)(mongo)
         fhirResources[module.name] = module
         logger.info(`Loaded FHIR resource module: ${module.name}`)