openhim-core/lib/middleware/rerunUpdateTransactionTask.js

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

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.setAttemptNumber = setAttemptNumber;
exports.updateOriginalTransaction = updateOriginalTransaction;
exports.updateTask = updateTask;
exports.koaMiddleware = koaMiddleware;

var _winston = require('winston');

var _winston2 = _interopRequireDefault(_winston);

var _statsdClient = require('statsd-client');

var _statsdClient2 = _interopRequireDefault(_statsdClient);

var _os = require('os');

var _os2 = _interopRequireDefault(_os);

var _transactions = require('../model/transactions');

var _tasks = require('../model/tasks');

var _config = require('../config');

var _util = require('util');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const statsdServer = _config.config.get('statsd');
const application = _config.config.get('application');

const domain = `${_os2.default.hostname()}.${application.name}.appMetrics`;
const sdc = new _statsdClient2.default(statsdServer);

function setAttemptNumber(ctx, done) {
  return _transactions.TransactionModel.findOne({ _id: ctx.parentID }, (err, transaction) => {
    if (err) {
      return done(err);
    }
    if (transaction.autoRetry) {
      if (transaction.autoRetryAttempt != null) {
        ctx.currentAttempt = transaction.autoRetryAttempt + 1;
      } else {
        ctx.currentAttempt = 1;
      }
    }
    return transaction.save((err, tx) => {
      if (err) {
        _winston2.default.error(`Original transaction ${transaction._id} could not be updated: ${err}`);
      } else {
        _winston2.default.debug(`Original transaction #${tx._id} Updated successfully with attempt number`);
      }

      return done(null);
    });
  });
}

function updateOriginalTransaction(ctx, done) {
  return _transactions.TransactionModel.findOne({ _id: ctx.parentID }, (err, transaction) => {
    if (err) {
      return done(err);
    }
    transaction.childIDs.push(ctx.transactionId);
    transaction.wasRerun = true;

    return transaction.save((err, tx) => {
      if (err) {
        _winston2.default.error(`Original transaction ${transaction._id} could not be updated: ${err}`);
      } else {
        _winston2.default.debug(`Original transaction ${tx._id} - Updated successfully with childID`);
      }

      return done(null, transaction);
    });
  });
}

function updateTask(ctx, done) {
  return _tasks.TaskModel.findOne({ _id: ctx.taskID }, (err, task) => {
    if (err) {
      return done(err);
    }
    task.transactions.forEach(tx => {
      if (tx.tid === ctx.parentID) {
        tx.rerunID = ctx.transactionId;
        tx.rerunStatus = ctx.transactionStatus;
      }
    });

    return task.save((err, task) => {
      if (err) {
        _winston2.default.info(`Rerun Task ${ctx.taskID} could not be updated: ${err}`);
      } else {
        _winston2.default.info(`Rerun Task ${ctx.taskID} - Updated successfully with rerun transaction details.`);
      }

      return done(null, task);
    });
  });
}

/*
 * Koa middleware for updating original transaction with childID
 */
async function koaMiddleware(ctx, next) {
  let startTime;
  if (statsdServer.enabled) {
    startTime = new Date();
  }
  const setAttempt = (0, _util.promisify)(setAttemptNumber);
  await setAttempt(ctx);
  if (statsdServer.enabled) {
    sdc.timing(`${domain}.rerunUpdateTransactionMiddleware.setAttemptNumber`, startTime);
  }

  // do intial yield for koa to come back to ctx function with updated ctx object
  await next();
  if (statsdServer.enabled) {
    startTime = new Date();
  }
  const _updateOriginalTransaction = (0, _util.promisify)(updateOriginalTransaction);
  await _updateOriginalTransaction(ctx);

  const _updateTask = (0, _util.promisify)(updateTask);
  await _updateTask(ctx);
  if (statsdServer.enabled) {
    sdc.timing(`${domain}.rerunUpdateTransactionMiddleware`, startTime);
  }
}
//# sourceMappingURL=rerunUpdateTransactionTask.js.map