@gabrielvgx/tecfoodcli/lib/questions/question.js

Projeto para automatizar criação de ambientes TecFood

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _prompts = _interopRequireDefault(require("prompts"));

var _async = _interopRequireDefault(require("async"));

var _template_option = require("./template_option.js");

var _app = _interopRequireDefault(require("../util/app.js"));

var _docker = _interopRequireDefault(require("../util/docker.js"));

var _genericQuestions = _interopRequireDefault(require("./modules/genericQuestions.js"));

var _ssh = _interopRequireDefault(require("./modules/ssh.js"));

var _apk = _interopRequireDefault(require("./modules/apk.js"));

var _cli_common_questions = _interopRequireDefault(require("../util/helpers/cli_common_questions.js"));

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

const question = {
  async requestCredentialsDocker(allRegistry) {
    let credentials = {};
    const OFFICIAL_DOCKER_REGISTRY = 'hub.docker.com';
    return _async.default.eachSeries(allRegistry, function (registry, callback) {
      (0, _template_option.text)(`Usuário para login docker (${registry || OFFICIAL_DOCKER_REGISTRY})`).then(({
        value: USER
      }) => {
        (0, _template_option.password)(`Senha para login docker (${registry || OFFICIAL_DOCKER_REGISTRY})`).then(({
          value: PASSWORD
        }) => {
          credentials[registry] = {
            USER,
            PASSWORD
          };
          callback();
        });
      });
    }).then(_ => credentials);
  },

  async persistCredentialsDocker(credentials) {
    return _async.default.eachSeries(Object.keys(credentials), function (REGISTRY, callback) {
      const {
        USER,
        PASSWORD
      } = credentials[REGISTRY];

      _docker.default.registerCredentials(USER, PASSWORD, REGISTRY).then(function (response) {
        if (response !== true) {
          console.log(`Error ${REGISTRY} ${response}`);
        }

        callback();
      });
    });
  },

  async initialQuest() {
    const {
      environments,
      useDefault,
      typeConfigure
    } = await (0, _prompts.default)([{
      type: 'select',
      name: 'typeConfigure',
      message: 'Em que posso ajudar?',
      choices: [{
        title: 'Ambientes',
        description: 'Configurar ambientes',
        value: 'ENV'
      }, {
        title: 'APK',
        description: 'Gerar APK - Cordova',
        value: 'APK'
      }, {
        title: 'SSH',
        description: 'Gerenciar SSH',
        value: 'SSH'
      }],
      initial: 0,
      hint: '- Use "arrow-up" "arrow-down" to navigate. <Enter> to submit'
    }, {
      type: prev => prev === 'ENV' ? 'multiselect' : null,
      name: 'environments',
      message: 'Ambientes a serem configurados',
      choices: [{
        title: 'Birt',
        value: 'birt'
      }, {
        title: 'Apps',
        value: 'app'
      }, {
        title: 'PHP 7.2 e Apache (based in cloud9)',
        value: 'basedev',
        selected: true
      }, {
        title: 'PHP 7.4 e Apache (based in cloud9)',
        value: 'basedev74'
      }, {
        title: 'Mongo 3.2',
        value: 'mongo'
      }, {
        title: 'Algoritmo - Otimizador',
        value: 'algoritmo'
      }],
      min: 1,
      hint: '- <Space> to select. <Enter> to submit'
    }, {
      type: prev => !!prev && !['SSH', 'APK'].includes(prev) ? 'select' : null,
      name: 'useDefault',
      message: 'Modo de configuração',
      choices: [{
        title: 'Padrão',
        description: 'Configuração automatizada (modo silencioso)',
        value: true
      }, {
        title: 'Avançado',
        description: 'Configuração detalhada com interações com usuário recorrentes',
        value: false
      }],
      initial: 0
    }]);

    if (!typeConfigure || !environments && typeConfigure === 'ENV' || typeof useDefault !== 'boolean' && !['SSH', 'APK'].includes(typeConfigure)) {
      const confirmExit = await _cli_common_questions.default.exit();

      if (confirmExit) {
        return 'EXIT';
      } else {
        return await this.initialQuest();
      }
    }

    return {
      environments: environments ? environments : [],
      useDefault,
      typeConfigure
    };
  },

  removeBuildParams(envParams) {
    let copyEnv = JSON.parse(JSON.stringify(envParams));
    Object.keys(copyEnv.services).forEach(serviceName => {
      delete copyEnv.services[serviceName].buildParams;
    });
    return copyEnv;
  },

  removeUnselectedServices(env, selectedServices) {
    let initialEnv = JSON.stringify(env);
    let modifiedEnv = initialEnv;
    initialEnv = JSON.parse(initialEnv);
    modifiedEnv = JSON.parse(modifiedEnv);
    Object.keys(initialEnv.services).forEach(serviceName => {
      if (!selectedServices.includes(serviceName)) {
        delete modifiedEnv.services[serviceName];
      }
    });
    return modifiedEnv;
  },

  async executeQuestions() {
    return new Promise(async (resolve, reject) => {
      const resultQuestions = await this.initialQuest();
      if (resultQuestions === 'EXIT') return 0;
      const {
        environments = [],
        useDefault = false,
        typeConfigure
      } = resultQuestions;
      let promiseQuestions = Promise.resolve(null);

      let defaultEnv = _app.default.getEnv();

      if (!useDefault) {
        switch (typeConfigure) {
          case 'SSH':
            promiseQuestions = _ssh.default.execute();
            break;

          case 'APK':
            promiseQuestions = _apk.default.execute();
            break;

          default:
            promiseQuestions = _async.default.eachSeries(environments, function (serviceName, next) {
              _genericQuestions.default.execute(defaultEnv.services[serviceName]).then(responseQuestion => {
                Object.assign(defaultEnv.services[serviceName], responseQuestion);
                next();
              });
            });
            break;
        }
      }

      const responseQuestions = await promiseQuestions;

      if (responseQuestions == 'BACK') {
        return this.executeQuestions().then(_ => resolve()).catch(_ => reject());
      }

      defaultEnv = this.removeBuildParams(defaultEnv);
      defaultEnv = this.removeUnselectedServices(defaultEnv, environments);

      _app.default.generateComposeFile(defaultEnv);

      let env = _app.default.getEnv();

      env = this.removeUnselectedServices(env, environments);
      const REGISTRY_SET = environments.reduce((setStructure, serviceName) => {
        let isPrivateRegistry = false;
        let {
          buildParams,
          image = ''
        } = env.services[serviceName] || {};

        if (buildParams && buildParams.private) {
          isPrivateRegistry = true;
        }

        if (isPrivateRegistry) {
          setStructure.add(_docker.default.getRegistryByImage(image) || '');
        }

        return setStructure;
      }, new Set());

      if (REGISTRY_SET && REGISTRY_SET.size) {
        this.requestCredentialsDocker(Array.from(REGISTRY_SET)).then(this.persistCredentialsDocker).then(_ => resolve(environments));
      } else {
        resolve(environments);
      }
    });
  }

};
var _default = question;
exports.default = _default;