openhim-core/lib/api/audits.js

The OpenHIM core application that provides logging and routing of http requests

var Audit, AuditMeta, Q, atna, auditLogUsed, auditing, authorisation, config, getProjectionObject, himSourceID, logger, os, utils;

Audit = require('../model/audits').Audit;

AuditMeta = require('../model/audits').AuditMeta;

authorisation = require('./authorisation');

Q = require('q');

logger = require('winston');

utils = require("../utils");

atna = require('atna-audit');

auditing = require('../auditing');

os = require('os');

config = require("../config/config");

config.router = config.get('router');

config.api = config.get('api');

himSourceID = config.get('auditing').auditEvents.auditSourceID;

getProjectionObject = function(filterRepresentation) {
  switch (filterRepresentation) {
    case "simpledetails":
      return {};
    case "full":
      return {};
    default:
      return {
        "participantObjectIdentification": 0,
        "activeParticipant": 0,
        "rawMessage": 0
      };
  }
};

auditLogUsed = function(auditId, outcome, user) {
  var audit, groups, uri;
  groups = user.groups.join(',');
  uri = "https://" + config.router.externalHostname + ":" + config.api.httpsPort + "/audits/" + auditId;
  audit = atna.auditLogUsedAudit(outcome, himSourceID, os.hostname(), user.email, groups, groups, uri);
  audit = atna.wrapInSyslog(audit);
  return auditing.sendAuditEvent(audit, function() {
    return logger.debug("Processed audit log used message for user '" + user.email + "' and audit '" + auditId + "'");
  });
};


/*
 * Adds a Audit
 */

exports.addAudit = function*() {
  var audit, auditData, e, error, result;
  if (!authorisation.inGroup('admin', this.authenticated)) {
    utils.logAndSetResponse(this, 403, "User " + this.authenticated.email + " is not an admin, API access to addAudit denied.", 'info');
    return;
  }
  auditData = this.request.body;
  try {
    audit = new Audit(auditData);
    result = (yield Q.ninvoke(audit, 'save'));
    (yield Q.ninvoke(auditing, 'processAuditMeta', audit));
    logger.info("User " + this.authenticated.email + " created audit with id " + audit.id);
    this.body = 'Audit successfully created';
    return this.status = 201;
  } catch (error) {
    e = error;
    logger.error("Could not add a audit via the API: " + e.message);
    this.body = e.message;
    return this.status = 400;
  }
};


/*
 * Retrieves the list of Audits
 */

exports.getAudits = function*() {
  var e, error, filterLimit, filterPage, filterRepresentation, filterSkip, filters, filtersObject, i, len, objectID, participantObjectID, patientID, projectionFiltersObject, record, ref, ref1, ref2, results;
  if (!authorisation.inGroup('admin', this.authenticated)) {
    utils.logAndSetResponse(this, 403, "User " + this.authenticated.email + " is not an admin, API access to getAudits denied.", 'info');
    return;
  }
  try {
    filtersObject = this.request.query;
    filterLimit = (ref = filtersObject.filterLimit) != null ? ref : 0;
    filterPage = (ref1 = filtersObject.filterPage) != null ? ref1 : 0;
    filterRepresentation = filtersObject.filterRepresentation;
    delete filtersObject.filterLimit;
    delete filtersObject.filterPage;
    delete filtersObject.filterRepresentation;
    filterSkip = filterPage * filterLimit;
    projectionFiltersObject = getProjectionObject(filterRepresentation);
    if (filtersObject.filters != null) {
      filters = JSON.parse(filtersObject.filters);
    } else {
      filters = {};
    }
    if (filters['eventIdentification.eventDateTime']) {
      filters['eventIdentification.eventDateTime'] = JSON.parse(filters['eventIdentification.eventDateTime']);
    }
    if (filters['participantObjectIdentification.participantObjectID']) {
      if (filters['participantObjectIdentification.participantObjectID'].type) {
        patientID = new RegExp(filters['participantObjectIdentification.participantObjectID'].patientID);
        objectID = new RegExp(filters['participantObjectIdentification.participantObjectID'].objectID);
        filters['$and'] = [
          {
            'participantObjectIdentification.participantObjectID': patientID
          }, {
            'participantObjectIdentification.participantObjectID': objectID
          }
        ];
        delete filters['participantObjectIdentification.participantObjectID'];
      } else {
        participantObjectID = JSON.parse(filters['participantObjectIdentification.participantObjectID']);
        filters['participantObjectIdentification.participantObjectID'] = new RegExp("" + participantObjectID);
      }
    }
    this.body = (yield Audit.find(filters, projectionFiltersObject).skip(filterSkip).limit(parseInt(filterLimit)).sort({
      'eventIdentification.eventDateTime': -1
    }).exec());
    if (filterRepresentation === 'full' || filterRepresentation === 'simpledetails') {
      ref2 = this.body;
      results = [];
      for (i = 0, len = ref2.length; i < len; i++) {
        record = ref2[i];
        results.push(auditLogUsed(record._id, atna.OUTCOME_SUCCESS, this.authenticated));
      }
      return results;
    }
  } catch (error) {
    e = error;
    return utils.logAndSetResponse(this, 500, "Could not retrieve audits via the API: " + e, 'error');
  }
};


/*
 * Retrieves the details for a specific Audit Record
 */

exports.getAuditById = function*(auditId) {
  var e, error, projectionFiltersObject, result;
  if (!authorisation.inGroup('admin', this.authenticated)) {
    utils.logAndSetResponse(this, 403, "User " + this.authenticated.email + " is not an admin, API access to getAuditById denied.", 'info');
    return;
  }
  auditId = unescape(auditId);
  try {
    projectionFiltersObject = getProjectionObject('full');
    result = (yield Audit.findById(auditId, projectionFiltersObject).exec());
    if (!result) {
      this.body = "Could not find audits record with ID: " + auditId;
      this.status = 404;
      return auditLogUsed(auditId, atna.OUTCOME_MINOR_FAILURE, this.authenticated);
    } else {
      this.body = result;
      return auditLogUsed(auditId, atna.OUTCOME_SUCCESS, this.authenticated);
    }
  } catch (error) {
    e = error;
    utils.logAndSetResponse(this, 500, "Could not get audit by ID via the API: " + e, 'error');
    return auditLogUsed(auditId, atna.OUTCOME_MAJOR_FAILURE, this.authenticated);
  }
};


/*
 * construct audit filtering dropdown options
 */

exports.getAuditsFilterOptions = function*() {
  var e, error;
  if (!authorisation.inGroup('admin', this.authenticated)) {
    utils.logAndSetResponse(this, 403, "User " + this.authenticated.email + " is not an admin, API access to getAudits denied.", 'info');
    return;
  }
  try {
    return this.body = (yield AuditMeta.findOne({}).exec());
  } catch (error) {
    e = error;
    return utils.logAndSetResponse(this, 500, "Could not retrieve audits filter options via the API: " + e, 'error');
  }
};

//# sourceMappingURL=audits.js.map