@reactivehub/cli/dist/commands/actions.js

Event Cli Tols

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _chalk = require('chalk');

var _chalk2 = _interopRequireDefault(_chalk);

var _inquirer = require('../libs/inquirer');

var _inquirer2 = _interopRequireDefault(_inquirer);

var _event = require('../core/event');

var _event2 = _interopRequireDefault(_event);

var _filter = require('../core/filter');

var _filter2 = _interopRequireDefault(_filter);

var _messages = require('../messages');

var _messages2 = _interopRequireDefault(_messages);

var _actions = require('../actions');

var _actions2 = _interopRequireDefault(_actions);

var _actions3 = require('../core/actions');

var _actions4 = _interopRequireDefault(_actions3);

var _serviceAccounts = require('../serviceAccounts');

var _serviceAccounts2 = _interopRequireDefault(_serviceAccounts);

var _action = require('./questions/action');

var _action2 = _interopRequireDefault(_action);

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

const checkEvent = eventId => {
  if (!_event2.default.eventExists(eventId)) {
    _messages2.default.error(`${_chalk2.default.blue.bold(eventId)} does not exists!`);
    return false;
  }
  return true;
};

const checkFilter = (eventId, filterId) => {
  if (!_filter2.default.filterExists(eventId, filterId)) {
    _messages2.default.error(`Filter ${_chalk2.default.blue.bold(filterId)} does not exists on ${_chalk2.default.blue.bold(eventId)}.`);
    return false;
  }
  return true;
};

const getServiceAccounts = (() => {
  var _ref = (0, _asyncToGenerator3.default)(function* (type) {
    const serviceAccountsOfType = yield _serviceAccounts2.default.getServiceAccounts({ type });
    if (!serviceAccountsOfType || serviceAccountsOfType.length === 0) {
      _messages2.default.error(`Service accounts of type ${_chalk2.default.blue.bold(type)} does not exists!`);
      _messages2.default.info(`Go to https://console.reactivehub.io/service-accounts/new/${type} and create a new service account entry.`);
      return null;
    }
    return serviceAccountsOfType;
  });

  return function getServiceAccounts(_x) {
    return _ref.apply(this, arguments);
  };
})();

const actionQuestions = (() => {
  var _ref2 = (0, _asyncToGenerator3.default)(function* (actionConfig, { id, eventId, filterId, type, action, serviceAccountId, async }) {
    try {
      const { actions: configActions = [] } = actionConfig;
      let { questions, buildTemplate } = actionConfig;

      let operation = null;
      if (configActions && configActions.length > 0) {
        const { operation: selectedOperation } = yield (0, _inquirer2.default)(_action2.default.chooseActionOperation(action, configActions.map(function ({ name }) {
          return name;
        })));
        const filteredOperation = configActions.filter(function ({ name }) {
          return name === selectedOperation;
        }).shift() || {};
        const { buildTemplate: operationTemplate, questions: operationQuestions } = filteredOperation;
        buildTemplate = operationTemplate;
        operation = selectedOperation;
        questions = operationQuestions;
      }
      const creatActionPayload = {
        id,
        async,
        eventId,
        filterId,
        type,
        action,
        operation,
        serviceAccountId
      };

      const eventPayloadModel = _event2.default.loadModelAsPayload(eventId);
      if (questions) {
        return (0, _inquirer2.default)(questions(eventPayloadModel)).then(function (answers) {
          return _actions4.default.createAction((0, _extends3.default)({}, creatActionPayload, {
            template: buildTemplate(answers, eventPayloadModel)
          }));
        }).catch(function (err) {
          return console.error(err);
        });
      }

      return _actions4.default.createAction((0, _extends3.default)({}, creatActionPayload, {
        template: buildTemplate({}, eventPayloadModel)
      }));
    } catch (e) {
      console.log(e);
      return false;
    }
  });

  return function actionQuestions(_x2, _x3) {
    return _ref2.apply(this, arguments);
  };
})();

const addAction = program => {
  program.command('add:action <eventId> <filterId> <type> <action>').description('Add a New Event').action((() => {
    var _ref3 = (0, _asyncToGenerator3.default)(function* (eventId, filterId, type, action) {
      try {
        if (!checkEvent(eventId)) return false;
        if (!checkFilter(eventId, filterId)) return false;
        const actionConfig = _actions2.default.getActionConfig(type, action);
        if (!actionConfig) return false;
        const serviceAccounts = yield getServiceAccounts(type);
        if (!serviceAccounts) return false;

        const { serviceAccountId, id: actionId, async } = yield (0, _inquirer2.default)(_action2.default.create(serviceAccounts));
        const actionExists = _actions4.default.actionExists(eventId, filterId, actionId);
        let continueIfExists = !actionExists;

        if (actionExists) {
          const { overrideConfirm } = yield (0, _inquirer2.default)(_action2.default.overrideAction(eventId, filterId, actionId));
          continueIfExists = overrideConfirm;
        }

        if (!continueIfExists) {
          _messages2.default.info('Operation aborted, nothing changed!');
          return true;
        }

        return actionQuestions(actionConfig, { id: actionId, eventId, filterId, type, action, serviceAccountId, async });
      } catch (e) {
        console.log(e);
      }
    });

    return function (_x4, _x5, _x6, _x7) {
      return _ref3.apply(this, arguments);
    };
  })());
};

exports.default = {
  addAction
};
//# sourceMappingURL=actions.js.map