NodeBB/NodeBB

'use strict';

const fs = require('fs');
const url = require('url');
const path = require('path');
const prompt = require('prompt');
const winston = require('winston');
const nconf = require('nconf');
const _ = require('lodash');

const utils = require('./utils');
const { paths } = require('./constants');

const install = module.exports;
const questions = {};

questions.main = [
    {
        name: 'url',
        description: 'URL used to access this NodeBB',
        default:
            nconf.get('url') || 'http://localhost:4567',
        pattern: /^http(?:s)?:\/\//,
        message: 'Base URL must begin with \'http://\' or \'https://\'',
    },
    {
        name: 'secret',
        description: 'Please enter a NodeBB secret',
        default: nconf.get('secret') || utils.generateUUID(),
    },
    {
        name: 'submitPluginUsage',
        description: 'Would you like to submit anonymous plugin usage to nbbpm?',
        default: 'yes',
    },
    {
        name: 'database',
        description: 'Which database to use',
        default: nconf.get('database') || 'mongo',
    },
];

questions.optional = [
    {
        name: 'port',
        default: nconf.get('port') || 4567,
    },
];

function checkSetupFlagEnv() {
    let setupVal = install.values;

    const envConfMap = {
        CONFIG: 'config',
        NODEBB_CONFIG: 'config',
        NODEBB_URL: 'url',
        NODEBB_PORT: 'port',
        NODEBB_ADMIN_USERNAME: 'admin:username',
        NODEBB_ADMIN_PASSWORD: 'admin:password',
        NODEBB_ADMIN_EMAIL: 'admin:email',
        NODEBB_DB: 'database',
        NODEBB_DB_HOST: 'host',
        NODEBB_DB_PORT: 'port',
        NODEBB_DB_USER: 'username',
        NODEBB_DB_PASSWORD: 'password',
        NODEBB_DB_NAME: 'database',
        NODEBB_DB_SSL: 'ssl',
    };

    // Set setup values from env vars (if set)
    const envKeys = Object.keys(process.env);
    if (Object.keys(envConfMap).some(key => envKeys.includes(key))) {
        winston.info('[install/checkSetupFlagEnv] checking env vars for setup info...');
        setupVal = setupVal || {};

        Object.entries(process.env).forEach(([evName, evValue]) => { // get setup values from env
            if (evName.startsWith('NODEBB_DB_')) {
                setupVal[`${process.env.NODEBB_DB}:${envConfMap[evName]}`] = evValue;
            } else if (evName.startsWith('NODEBB_')) {
                setupVal[envConfMap[evName]] = evValue;
            }
        });

        setupVal['admin:password:confirm'] = setupVal['admin:password'];
    }

    // try to get setup values from json, if successful this overwrites all values set by env
    // TODO: better behaviour would be to support overrides per value, i.e. in order of priority (generic pattern):
    //       flag, env, config file, default
    try {
        if (nconf.get('setup')) {
            const setupJSON = JSON.parse(nconf.get('setup'));
            setupVal = { ...setupVal, ...setupJSON };
        }
    } catch (err) {
        winston.error('[install/checkSetupFlagEnv] invalid json in nconf.get(\'setup\'), ignoring setup values from json');
    }

    if (setupVal && typeof setupVal === 'object') {
        if (setupVal['admin:username'] && setupVal['admin:password'] && setupVal['admin:password:confirm'] && setupVal['admin:email']) {
            install.values = setupVal;
        } else {
            winston.error('[install/checkSetupFlagEnv] required values are missing for automated setup:');
            if (!setupVal['admin:username']) {
                winston.error('  admin:username');
            }
            if (!setupVal['admin:password']) {
                winston.error('  admin:password');
            }
            if (!setupVal['admin:password:confirm']) {
                winston.error('  admin:password:confirm');
            }
            if (!setupVal['admin:email']) {
                winston.error('  admin:email');
            }

            process.exit();
        }
    } else if (nconf.get('database')) {
        install.values = install.values || {};
        install.values.database = nconf.get('database');
    }
}

function checkCIFlag() {
    let ciVals;
    try {
        ciVals = JSON.parse(nconf.get('ci'));
    } catch (e) {
        ciVals = undefined;
    }

    if (ciVals && ciVals instanceof Object) {
        if (ciVals.hasOwnProperty('host') && ciVals.hasOwnProperty('port') && ciVals.hasOwnProperty('database')) {
            install.ciVals = ciVals;
        } else {
            winston.error('[install/checkCIFlag] required values are missing for automated CI integration:');
            if (!ciVals.hasOwnProperty('host')) {
                winston.error('  host');
            }
            if (!ciVals.hasOwnProperty('port')) {
                winston.error('  port');
            }
            if (!ciVals.hasOwnProperty('database')) {
                winston.error('  database');
            }

            process.exit();
        }
    }
}

async function setupConfig() {
    const configureDatabases = require('../install/databases');

    // prompt prepends "prompt: " to questions, let's clear that.
    prompt.start();
    prompt.message = '';
    prompt.delimiter = '';
    prompt.colors = false;
    let config = {};

    if (install.values) {
        // Use provided values, fall back to defaults
        const redisQuestions = require('./database/redis').questions;
        const mongoQuestions = require('./database/mongo').questions;
        const postgresQuestions = require('./database/postgres').questions;
        const allQuestions = [
            ...questions.main,
            ...questions.optional,
            ...redisQuestions,
            ...mongoQuestions,
            ...postgresQuestions,
        ];

        allQuestions.forEach((question) => {
            if (install.values.hasOwnProperty(question.name)) {
                config[question.name] = install.values[question.name];
            } else if (question.hasOwnProperty('default')) {
                config[question.name] = question.default;
            } else {
                config[question.name] = undefined;
            }
        });
    } else {
        config = await prompt.get(questions.main);
    }
    await configureDatabases(config);
    await completeConfigSetup(config);
}

async function completeConfigSetup(config) {
    // Add CI object
    if (install.ciVals) {
        config.test_database = { ...install.ciVals };
    }

    // Add package_manager object if set
    if (nconf.get('package_manager')) {
        config.package_manager = nconf.get('package_manager');
    }
    nconf.overrides(config);
    const db = require('./database');
    await db.init();
    if (db.hasOwnProperty('createIndices')) {
        await db.createIndices();
    }

    // Sanity-check/fix url/port
    if (!/^http(?:s)?:\/\//.test(config.url)) {
        config.url = `http://${config.url}`;
    }

    // If port is explicitly passed via install vars, use it. Otherwise, glean from url if set.
    const urlObj = url.parse(config.url);
    if (urlObj.port && (!install.values || !install.values.hasOwnProperty('port'))) {
        config.port = urlObj.port;
    }

    // Remove trailing slash from non-subfolder installs
    if (urlObj.path === '/') {
        urlObj.path = '';
        urlObj.pathname = '';
    }

    config.url = url.format(urlObj);

    // ref: https://github.com/indexzero/nconf/issues/300
    delete config.type;

    const meta = require('./meta');
    await meta.configs.set('submitPluginUsage', config.submitPluginUsage === 'yes' ? 1 : 0);
    delete config.submitPluginUsage;

    await install.save(config);
}

async function setupDefaultConfigs() {
    console.log('Populating database with default configs, if not already set...');
    const meta = require('./meta');
    const defaults = require(path.join(__dirname, '../', 'install/data/defaults.json'));

    await meta.configs.setOnEmpty(defaults);
    await meta.configs.init();
}

async function enableDefaultTheme() {
    const meta = require('./meta');

    const id = await meta.configs.get('theme:id');
    if (id) {
        console.log('Previous theme detected, skipping enabling default theme');
        return;
    }

    const defaultTheme = nconf.get('defaultTheme') || 'nodebb-theme-harmony';
    console.log(`Enabling default theme: ${defaultTheme}`);
    await meta.themes.set({
        type: 'local',
        id: defaultTheme,
    });
}

async function createDefaultUserGroups() {
    const groups = require('./groups');
    async function createGroup(name) {
        await groups.create({
            name: name,
            hidden: 1,
            private: 1,
            system: 1,
            disableLeave: 1,
            disableJoinRequests: 1,
        });
    }

    const [verifiedExists, unverifiedExists, bannedExists] = await groups.exists([
        'verified-users', 'unverified-users', 'banned-users',
    ]);
    if (!verifiedExists) {
        await createGroup('verified-users');
    }

    if (!unverifiedExists) {
        await createGroup('unverified-users');
    }

    if (!bannedExists) {
        await createGroup('banned-users');
    }
}

async function createAdministrator() {
    const Groups = require('./groups');
    const memberCount = await Groups.getMemberCount('administrators');
    if (memberCount > 0) {
        console.log('Administrator found, skipping Admin setup');
        return;
    }
    return await createAdmin();
}

async function createAdmin() {
    const User = require('./user');
    const Groups = require('./groups');
    let password;

    winston.warn('No administrators have been detected, running initial user setup\n');

    let questions = [{
        name: 'username',
        description: 'Administrator username',
        required: true,
        type: 'string',
    }, {
        name: 'email',
        description: 'Administrator email address',
        pattern: /.+@.+/,
        required: true,
    }];
    const passwordQuestions = [{
        name: 'password',
        description: 'Password',
        required: true,
        hidden: true,
        type: 'string',
    }, {
        name: 'password:confirm',
        description: 'Confirm Password',
        required: true,
        hidden: true,
        type: 'string',
    }];

    async function success(results) {
        if (!results) {
            throw new Error('aborted');
        }

        if (results['password:confirm'] !== results.password) {
            winston.warn('Passwords did not match, please try again');
            return await retryPassword(results);
        }

        try {
            User.isPasswordValid(results.password);
        } catch (err) {
            const [namespace, key] = err.message.slice(2, -2).split(':', 2);
            if (namespace && key && err.message.startsWith('[[') && err.message.endsWith(']]')) {
                const lang = require(path.join(__dirname, `../public/language/en-GB/${namespace}`));
                if (lang && lang[key]) {
                    err.message = lang[key];
                }
            }

            winston.warn(`Password error, please try again. ${err.message}`);
            return await retryPassword(results);
        }

        const adminUid = await User.create({
            username: results.username,
            password: results.password,
            email: results.email,
        });
        await Groups.join('administrators', adminUid);
        await Groups.show('administrators');
        await Groups.ownership.grant(adminUid, 'administrators');

        return password ? results : undefined;
    }

    async function retryPassword(originalResults) {
        // Ask only the password questions
        const results = await prompt.get(passwordQuestions);

        // Update the original data with newly collected password
        originalResults.password = results.password;
        originalResults['password:confirm'] = results['password:confirm'];

        // Send back to success to handle
        return await success(originalResults);
    }

    // Add the password questions
    questions = questions.concat(passwordQuestions);

    if (!install.values) {
        const results = await prompt.get(questions);
        return await success(results);
    }
    // If automated setup did not provide a user password, generate one,
    // it will be shown to the user upon setup completion
    if (!install.values.hasOwnProperty('admin:password') && !nconf.get('admin:password')) {
        console.log('Password was not provided during automated setup, generating one...');
        password = utils.generateUUID().slice(0, 8);
    }

    const results = {
        username: install.values['admin:username'] || nconf.get('admin:username') || 'admin',
        email: install.values['admin:email'] || nconf.get('admin:email') || '',
        password: install.values['admin:password'] || nconf.get('admin:password') || password,
        'password:confirm': install.values['admin:password:confirm'] || nconf.get('admin:password') || password,
    };

    return await success(results);
}

async function createGlobalModeratorsGroup() {
    const groups = require('./groups');
    const exists = await groups.exists('Global Moderators');
    if (exists) {
        winston.info('Global Moderators group found, skipping creation!');
    } else {
        await groups.create({
            name: 'Global Moderators',
            userTitle: 'Global Moderator',
            description: 'Forum wide moderators',
            hidden: 0,
            private: 1,
            disableJoinRequests: 1,
        });
    }
    await groups.show('Global Moderators');
}

async function giveGlobalPrivileges() {
    const privileges = require('./privileges');
    const defaultPrivileges = [
        'groups:chat', 'groups:upload:post:image', 'groups:signature', 'groups:search:content',
        'groups:search:users', 'groups:search:tags', 'groups:view:users', 'groups:view:tags', 'groups:view:groups',
        'groups:local:login',
    ];
    await privileges.global.give(defaultPrivileges, 'registered-users');
    await privileges.global.give(defaultPrivileges.concat([
        'groups:ban', 'groups:upload:post:file', 'groups:view:users:info',
    ]), 'Global Moderators');
    await privileges.global.give(['groups:view:users', 'groups:view:tags', 'groups:view:groups'], 'guests');
    await privileges.global.give(['groups:view:users', 'groups:view:tags', 'groups:view:groups'], 'spiders');
}

async function createCategories() {
    const Categories = require('./categories');
    const db = require('./database');
    const cids = await db.getSortedSetRange('categories:cid', 0, -1);
    if (Array.isArray(cids) && cids.length) {
        console.log(`Categories OK. Found ${cids.length} categories.`);
        return;
    }

    console.log('No categories found, populating instance with default categories');

    const default_categories = JSON.parse(
        await fs.promises.readFile(path.join(__dirname, '../', 'install/data/categories.json'), 'utf8')
    );
    for (const categoryData of default_categories) {
        // eslint-disable-next-line no-await-in-loop
        await Categories.create(categoryData);
    }
}

async function createMenuItems() {
    const db = require('./database');

    const exists = await db.exists('navigation:enabled');
    if (exists) {
        return;
    }
    const navigation = require('./navigation/admin');
    const data = require('../install/data/navigation.json');
    await navigation.save(data);
}

async function createWelcomePost() {
    const db = require('./database');
    const Topics = require('./topics');

    const [content, numTopics] = await Promise.all([
        fs.promises.readFile(path.join(__dirname, '../', 'install/data/welcome.md'), 'utf8'),
        db.getObjectField('global', 'topicCount'),
    ]);

    if (!parseInt(numTopics, 10)) {
        console.log('Creating welcome post!');
        await Topics.post({
            uid: 1,
            cid: 2,
            title: 'Welcome to your NodeBB!',
            content: content,
        });
    }
}

async function enableDefaultPlugins() {
    console.log('Enabling default plugins');

    let defaultEnabled = [
        'nodebb-plugin-composer-default',
        'nodebb-plugin-markdown',
        'nodebb-plugin-mentions',
        'nodebb-widget-essentials',
        'nodebb-rewards-essentials',
        'nodebb-plugin-emoji',
        'nodebb-plugin-emoji-android',
    ];
    let customDefaults = nconf.get('defaultplugins') || nconf.get('defaultPlugins');

    winston.info(`[install/defaultPlugins] customDefaults ${String(customDefaults)}`);

    if (customDefaults && customDefaults.length) {
        try {
            customDefaults = Array.isArray(customDefaults) ? customDefaults : JSON.parse(customDefaults);
            defaultEnabled = defaultEnabled.concat(customDefaults);
        } catch (e) {
            // Invalid value received
            winston.info('[install/enableDefaultPlugins] Invalid defaultPlugins value received. Ignoring.');
        }
    }

    defaultEnabled = _.uniq(defaultEnabled);

    winston.info('[install/enableDefaultPlugins] activating default plugins', defaultEnabled);

    const db = require('./database');
    const order = defaultEnabled.map((plugin, index) => index);
    await db.sortedSetAdd('plugins:active', order, defaultEnabled);
}

async function setCopyrightWidget() {
    const db = require('./database');
    const [footerJSON, footer] = await Promise.all([
        fs.promises.readFile(path.join(__dirname, '../', 'install/data/footer.json'), 'utf8'),
        db.getObjectField('widgets:global', 'footer'),
    ]);

    if (!footer && footerJSON) {
        await db.setObjectField('widgets:global', 'sidebar-footer', footerJSON);
    }
}

async function copyFavicon() {
    const file = require('./file');
    const pathToIco = path.join(nconf.get('upload_path'), 'system', 'favicon.ico');
    const defaultIco = path.join(nconf.get('base_dir'), 'public', 'favicon.ico');
    const targetExists = await file.exists(pathToIco);
    const defaultExists = await file.exists(defaultIco);

    if (defaultExists && !targetExists) {
        try {
            await fs.promises.copyFile(defaultIco, pathToIco);
        } catch (err) {
            winston.error(`Cannot copy favicon.ico\n${err.stack}`);
        }
    }
}

async function checkUpgrade() {
    const upgrade = require('./upgrade');
    try {
        await upgrade.check();
    } catch (err) {
        if (err.message === 'schema-out-of-date') {
            await upgrade.run();
            return;
        }
        throw err;
    }
}

async function installPlugins() {
    const pluginInstall = require('./plugins');
    const nbbVersion = require(paths.currentPackage).version;
    await Promise.all((await pluginInstall.getActive()).map(async (id) => {
        if (await pluginInstall.isInstalled(id)) return;
        const version = await pluginInstall.suggest(id, nbbVersion);
        await pluginInstall.toggleInstall(id, version.version);
    }));
}

install.setup = async function () {
    try {
        checkSetupFlagEnv();
        checkCIFlag();
        await setupConfig();
        await setupDefaultConfigs();
        await enableDefaultTheme();
        await createCategories();
        await createDefaultUserGroups();
        const adminInfo = await createAdministrator();
        await createGlobalModeratorsGroup();
        await giveGlobalPrivileges();
        await createMenuItems();
        await createWelcomePost();
        await enableDefaultPlugins();
        await setCopyrightWidget();
        await copyFavicon();
        if (nconf.get('plugins:autoinstall')) await installPlugins();
        await checkUpgrade();

        const data = {
            ...adminInfo,
        };
        return data;
    } catch (err) {
        if (err) {
            winston.warn(`NodeBB Setup Aborted.\n ${err.stack}`);
            process.exit(1);
        }
    }
};

install.save = async function (server_conf) {
    let serverConfigPath = path.join(__dirname, '../config.json');

    if (nconf.get('config')) {
        serverConfigPath = path.resolve(__dirname, '../', nconf.get('config'));
    }

    let currentConfig = {};
    try {
        currentConfig = require(serverConfigPath);
    } catch (err) {
        if (err.code !== 'MODULE_NOT_FOUND') {
            throw err;
        }
    }

    await fs.promises.writeFile(serverConfigPath, JSON.stringify({ ...currentConfig, ...server_conf }, null, 4));
    console.log('Configuration Saved OK');
    nconf.file({
        file: serverConfigPath,
    });
};