install.js

var async = require('async');
var chalk = require('chalk');
var fs = require('fs-extra');
var optimist = require('optimist');
var path = require('path');
var crypto = require('crypto');

var auth = require('./lib/auth');
var database = require('./lib/database');
var helpers = require('./lib/helpers');
var installHelpers = require('./lib/installHelpers');
var localAuth = require('./plugins/auth/local');
var logger = require('./lib/logger');
var origin = require('./lib/application');

var IS_INTERACTIVE = process.argv.length === 2;
var USE_CONFIG;

var app = origin();
// config for prompt inputs
var inputData;
var masterTenant = false;
var superUser = false;
// from user input
var configResults = {};
var configOverrides = {};

installHelpers.checkPrimaryDependencies(function(error) {
  if(error) return handleError(null, 1, error);
  // we need the framework version for the config items, so let's go
  installHelpers.getLatestFrameworkVersion(function(error, latestFrameworkTag) {
    if(error) {
      return handleError(error, 1, 'Failed to get the latest framework version. Check package.json.');
    }
    inputData = {
      useConfigJSON: [
        {
          name: 'useJSON',
          message: 'Use existing config values?',
          type: 'confirm',
          default: false
        }
      ],
      startInstall: [
        {
          name: 'install',
          message: 'Continue?',
          type: 'confirm',
          default: true
        }
      ],
      server: [
        {
          name: 'serverPort',
          type: 'number',
          message: 'Server port',
          validate: installHelpers.inputHelpers.numberValidator,
          default: 5000
        },
        {
          name: 'serverName',
          type: 'input',
          message: 'Server name',
          default: 'localhost'
        },
        {
          name: 'dataRoot',
          type: 'input',
          message: 'Data directory path',
          validate: installHelpers.inputHelpers.alphanumValidator,
          default: 'data'
        },
        {
          name: 'authoringToolRepository',
          type: 'input',
          message: 'Git repository URL to be used for the authoring tool source code',
          default: 'https://github.com/adaptlearning/adapt_authoring.git'
        },
        {
          name: 'frameworkRepository',
          type: 'input',
          message: 'Git repository URL to be used for the framework source code',
          default: 'https://github.com/adaptlearning/adapt_framework.git'
        },
        {
          name: 'frameworkRevision',
          type: 'input',
          message: 'Specific git revision to be used for the framework. Accepts any valid revision type (e.g. branch/tag/commit)',
          default: 'tags/' + latestFrameworkTag
        }
      ],
      database: {
        dbConfig: [
          {
            name: 'dbName',
            type: 'input',
            message: 'Master database name',
            validate: installHelpers.inputHelpers.alphanumValidator,
            default: 'adapt-tenant-master'
          },
          {
            name: 'useConnectionUri',
            type: 'confirm',
            message: 'Will you be using a full database connection URI? (all connection options in the URI)',
            default: false
          }
        ],
        configureUri: [
          {
            name: 'dbConnectionUri',
            type: 'input',
            message: 'Database connection URI',
            default: ''
          }
        ],
        configureStandard: [
          {
            name: 'dbHost',
            type: 'input',
            message: 'Database host',
            default: 'localhost'
          },
          {
            name: 'dbPort',
            type: 'number',
            message: 'Database server port',
            validate: installHelpers.inputHelpers.numberValidator,
            default: 27017
          },
          {
            name: 'dbUser',
            type: 'input',
            message: 'Database server user (only specify if using database authentication)',
            validate: installHelpers.inputHelpers.alphanumValidator,
            default: ''
          },
          {
            name: 'dbPass',
            type: 'password',
            message: 'Database server password (only specify if using database authentication)',
            mask: installHelpers.inputHelpers.passwordReplace,
            validate: installHelpers.inputHelpers.alphanumValidator,
            default: ''
          },
          {
            name: 'dbAuthSource',
            type: 'input',
            message: 'Database server authentication database (only specify if using database authentication)',
            validate: installHelpers.inputHelpers.alphanumValidator,
            default: ''
          },
        ]
      },
      features: {
        smtp: {
          confirm: [
            {
              name: 'useSmtp',
              type: 'confirm',
              message: 'Will you be using an SMTP server? (used for sending emails)',
              default: false
            }
          ],
          confirmConnectionUrl: [
            {
              name: 'useSmtpConnectionUrl',
              type: 'confirm',
              message: 'Will you use a URL to connect to your smtp Server',
              default: false
            }
          ],
          configure: [
            {
              name: 'fromAddress',
              type: 'input',
              message: 'Sender email address',
              default: '',
            },
            {
              name: 'rootUrl',
              type: 'input',
              message: 'The url this install will be accessible from',
              default: '' // set using default server options
            }
          ],
          configureService: [
            {
              name: 'smtpService',
              type: 'input',
              message: 'Which SMTP service (if any) will be used? (see https://github.com/andris9/nodemailer-wellknown#supported-services for a list of supported services.)',
              default: 'none',
            },
            {
              name: 'smtpUsername',
              type: 'input',
              message: 'SMTP username',
              default: '',
            },
            {
              name: 'smtpPassword',
              type: 'password',
              message: 'SMTP password',
              mask: installHelpers.inputHelpers.passwordReplace,
              default: ''
            }
          ],
          configureConnectionUrl: [
            {
              name: 'smtpConnectionUrl',
              type: 'input',
              message: 'Custom connection URL: smtps://user%40gmail.com:pass@smtp.gmail.com/?pool=true',
              default: 'none',
            }
          ]
        }
      },
      tenant: [
        {
          name: 'masterTenantName',
          type: 'input',
          message: 'Set a unique name for your tenant',
          validate: installHelpers.inputHelpers.alphanumValidator,
          default: 'master'
        },
        {
          name: 'masterTenantDisplayName',
          type: 'input',
          message: 'Set the display name for your tenant',
          default: 'Master'
        }
      ],
      tenantDelete: [
        {
          name: 'confirm',
          type: 'confirm',
          message: 'Continue?',
          default: true
        }
      ],
      superUser: [
        {
          name: 'suEmail',
          type: 'input',
          message: 'Email address',
          validate: installHelpers.inputHelpers.requiredValidator
        },
        {
          name: 'suPassword',
          type: 'password',
          message: 'Password',
          mask: installHelpers.inputHelpers.passwordReplace,
          validate: installHelpers.inputHelpers.requiredValidator
        },
        {
          name: 'suRetypePassword',
          type: 'password',
          message: 'Confirm Password',
          mask: installHelpers.inputHelpers.passwordReplace,
          validate: installHelpers.inputHelpers.requiredValidator
        }
      ]
    };
    if(!IS_INTERACTIVE) {
      if (installHelpers.inputHelpers.toBoolean(optimist.argv.useJSON)) {
        USE_CONFIG = true;
      }
      return start();
    }
    console.log('');
    if(!fs.existsSync('conf/config.json')) {
      fs.ensureDirSync('conf');
      return start();
    }
    console.log('Found an existing config.json file. Do you want to use the values in this file during install?');
    installHelpers.getInput(inputData.useConfigJSON, configOverrides, function(result) {
      console.log('');
      USE_CONFIG = result.useJSON;
      start();
    });
  });
});

// we need the framework version for the config items, so let's go

function generatePromptOverrides() {
  if(USE_CONFIG) {
    var configJson = require('./conf/config.json');
    var configData = JSON.parse(JSON.stringify(configJson));
    addConfig(configData);
    configData.install = true;
  }
  const sessionSecret = USE_CONFIG && configData.sessionSecret || crypto.randomBytes(64).toString('hex');
  addConfig({ sessionSecret: sessionSecret });
  // NOTE config.json < cmd args
  return Object.assign({}, configData, optimist.argv);
}

function start() {
  // set overrides from command line arguments and config.json
  configOverrides = generatePromptOverrides();
  // Prompt the user to begin the install
  if(!IS_INTERACTIVE || USE_CONFIG) {
    console.log('This script will install the application. Please wait ...');
  } else {
    console.log('This script will install the application. \nWould you like to continue?');
  }
  installHelpers.getInput(inputData.startInstall, configOverrides, function(result) {
    if(!result.install) {
      return handleError(null, 0, 'User cancelled the install');
    }
    async.series([
      configureServer,
      configureDatabase,
      configureFeatures,
      configureMasterTenant,
      createMasterTenant,
      createSuperUser,
      buildFrontend,
      syncMigrations
    ], function(error, results) {
      if(error) {
        console.error('ERROR: ', error);
        return exit(1, 'Install was unsuccessful. Please check the console output.');
      }
      exit(0, `Installation completed successfully, the application can now be started with 'node server'.`);
    });
  });
}

function configureServer(callback) {
  console.log('');
  if(!IS_INTERACTIVE || USE_CONFIG) {
    console.log('Now setting configuration items.');
  } else {
    console.log('We need to configure the tool before install. \nTip: just press ENTER to accept the default value in brackets.');
  }
  installHelpers.getLatestFrameworkVersion(function(error, latestFrameworkTag) {
    if(error) {
      return handleError(error, 1, 'Failed to get latest framework version');
    }
    installHelpers.getInput(inputData.server, configOverrides, function(result) {
      addConfig(result);
      callback();
    });
  });
}

function configureDatabase(callback) {
  installHelpers.getInput(inputData.database.dbConfig, configOverrides, function(result) {
    addConfig(result);

    var isStandard = !installHelpers.inputHelpers.toBoolean(result.useConnectionUri);
    var config = inputData.database[isStandard ? 'configureStandard' : 'configureUri'];

    installHelpers.getInput(config, configOverrides, function(result) {
      addConfig(result);
      callback();
    });
  });
}

function configureFeatures(callback) {
  async.series([
    function smtp(cb) {
      installHelpers.getInput(inputData.features.smtp.confirm, configOverrides, function(result) {
        addConfig(result);
        if (!installHelpers.inputHelpers.toBoolean(result.useSmtp)) {
          return cb();
        }
        // prompt user if custom connection url or well-known-service should be used
        installHelpers.getInput(inputData.features.smtp.confirmConnectionUrl, configOverrides, function(result) {
          addConfig(result);
          var smtpConfig;
          if (installHelpers.inputHelpers.toBoolean(result.useSmtpConnectionUrl)) {
            smtpConfig = inputData.features.smtp.configure.concat(inputData.features.smtp.configureConnectionUrl);
          } else {
            smtpConfig = inputData.features.smtp.configure.concat(inputData.features.smtp.configureService);
          }
          for(var i = 0, count = smtpConfig.length; i < count; i++) {
            if(smtpConfig[i].name === 'rootUrl') {
              smtpConfig[i].default = `http://${configResults.serverName}:${configResults.serverPort}`;
            }
          }
          installHelpers.getInput(smtpConfig, configOverrides, function(result) {
            addConfig(result);
            cb();
          });
        });
      });
    }
  ], function() {
    saveConfig(configResults, callback);
  });
}

function configureMasterTenant(callback) {
  var onError = function(error) {
    console.error('ERROR: ', error);
    return exit(1, 'Failed to configure master tenant. Please check the console output.');
  };
  if(!IS_INTERACTIVE || USE_CONFIG) {
    console.log('Now configuring the master tenant. \n');
  } else {
    console.log('Now we need to configure the master tenant. \nTip: just press ENTER to accept the default value in brackets.\n');
  }
  logger.level('console','error');
  // run the app
  app.run({ skipVersionCheck: true, skipDependencyCheck: true });
  app.on('serverStarted', function() {

    if(USE_CONFIG && configOverrides.masterTenantName) {
      /**
      * remove the masterTenantDisplayName, as we can use the existing value
      * (which isn't in config.json so can't be used as an auto override)
      */
      inputData.tenant = inputData.tenant.filter(item => item.name !== 'masterTenantDisplayName');
    }
    installHelpers.getInput(inputData.tenant, configOverrides, function(result) {
      console.log('');
      // add the input to our cached config
      addConfig({
        masterTenant: {
          name: result.masterTenantName,
          displayName: result.masterTenantDisplayName
        }
      });
      // check if the tenant name already exists
      app.tenantmanager.retrieveTenant({ name: result.masterTenantName }, function(error, tenant) {
        if(error) {
          return onError(error);
        }
        if(!tenant) {
          return callback();
        }
        if(!IS_INTERACTIVE) {
          return exit(1, `Tenant '${tenant.name}' already exists, automatic install cannot continue.`);
        }
        if(!configResults.masterTenant.displayName) {
          configResults.masterTenant.displayName = tenant.displayName;
        }
        console.log(chalk.yellow(`Tenant '${tenant.name}' already exists. ${chalk.underline('It must be deleted for install to continue.')}`));
        installHelpers.getInput(inputData.tenantDelete, configOverrides, function(result) {
          console.log('');
          if(!result.confirm) {
            return exit(1, 'Exiting install.');
          }
          // delete tenant
          async.eachSeries(app.db.getModelNames(), function(modelName, cb) {
            app.db.destroy(modelName, null, cb);
          }, callback);
        });
      });
    });
  });
}

function createMasterTenant(callback) {
  app.tenantmanager.createTenant({
    name: configResults.masterTenant.name,
    displayName: configResults.masterTenant.displayName,
    isMaster: true,
    database: {
      dbName: app.configuration.getConfig('dbName'),
      dbHost: app.configuration.getConfig('dbHost'),
      dbUser: app.configuration.getConfig('dbUser'),
      dbPass: app.configuration.getConfig('dbPass'),
      dbPort: app.configuration.getConfig('dbPort')
    }
  }, function(error, tenant) {
    if(error) {
      return handleError(error, 1, 'Failed to create master tenant. Please check the console output.');
    }
    console.log('Master tenant created successfully.');
    masterTenant = tenant;
    delete configResults.masterTenant;
    addConfig(app.configuration.getConfig());
    saveConfig(configResults, callback);
  });
}

function createSuperUser(callback) {
  var onError = function(error) {
    handleError(error, 1, 'Failed to create admin user account. Please check the console output.');
  };
  console.log(`\nNow we need to set up a 'Super Admin' account. This account can be used to manage everything on your authoring tool instance.`);
  installHelpers.getInput(inputData.superUser, configOverrides, function(result) {
    console.log('');
    app.usermanager.deleteUser({ email: result.suEmail }, function(error, userRec) {
      if(error) return onError(error);
      // add a new user using default auth plugin
      new localAuth().internalRegisterUser(true, {
        email: result.suEmail,
        password: result.suPassword,
        retypePassword: result.suRetypePassword,
        _tenantId: masterTenant._id
      }, function(error, user) {
        // TODO should we allow a retry if the passwords don't match?
        if(error) {
          return onError(error);
        }
        superUser = user;
        helpers.grantSuperPermissions(user._id, function(error) {
          if(error) return onError(error);
          return callback();
        });
      });
    });
  });
}

function buildFrontend(callback) {
  installHelpers.buildAuthoring(function(error) {
    if(error) {
      return callback(`Failed to build the web application, (${error}) \nInstall will continue. Try again after installation completes using 'grunt build:prod'.`);
    }
    callback();
  });
}

//As this is a fresh install we dont need to run the migrations so add them to the db and set them to up
function syncMigrations(callback) {
  installHelpers.syncMigrations(function(err, migrations) {
    database.getDatabase(function(err, db) {
      if(err) {
        return callback(err);
      }
      db.update('migration', {}, {'state': 'up'}, callback)
    }, masterTenant._id)
  });
}

// helper functions

function addConfig(newConfigItems) {
  Object.assign(configResults, newConfigItems);
}

/**
 * This will write out the config items both as a config.json file
 *
 * @param {object} configItems
 * @param {callback} callback
 */

function saveConfig(configItems, callback) {
  if (!IS_INTERACTIVE || USE_CONFIG) {
    for (var key in configItems) {
      if (configItems.hasOwnProperty(key) === false) continue;
      var value = configItems[key];
      if (typeof value !== 'string') continue;
      value = value.toLocaleLowerCase();
      if (value === 'y') {
        configItems[key] = true;
      } else if (value === 'n') {
        configItems[key] = false;
      }
    }
  }
  fs.ensureDir('conf', function(error) {
    if (error) {
      return handleError(`Failed to create configuration directory.\n${error}`, 1, 'Install Failed.');
    }
    // Create the final config (with some default values not set in this script)
    const config = Object.assign({
      outputPlugin: 'adapt',
      dbType: 'mongoose',
      auth: 'local',
      root: process.cwd()
    }, configItems);

    fs.writeJson(path.join('conf', 'config.json'), config, { spaces: 2 }, function(error) {
      if(error) {
        return handleError(`Failed to write configuration file to ${chalk.underline('conf/config.json')}.\n${error}`, 1, 'Install Failed.');
      }
      callback();
    });
  });
}

function handleError(error, exitCode, exitMessage) {
  if(error) {
    console.error(`ERROR: ${error}`);
  }
  if(exitCode) {
    exit(exitCode, exitMessage);
  }
}

/**
 * Exits the install with some cleanup, should there be an error
 *
 * @param {int} code
 * @param {string} msg
 */

function exit(code, msg) {
  installHelpers.exit(code, msg, function(callback) {
    if(0 === code || app && !app.db || !masterTenant) {
      return callback();
    }
    // handle borked tenant, users, in case of a non-zero exit
    app.db.destroy('tenant', { _id: masterTenant._id }, function(error) {
      if(!superUser) return callback();
      app.db.destroy('user', { _id: superUser._id }, callback);
    });
  });
}