cloudron-box/src/mailer.js

'use strict';

exports = module.exports = {
    passwordReset,

    sendInvite,
    sendNewLoginLocation,

    backupFailed,

    certificateRenewalError,

    sendTestMail,

    _mailQueue: [] // accumulate mails in test mode
};

const assert = require('assert'),
    BoxError = require('./boxerror.js'),
    debug = require('debug')('box:mailer'),
    ejs = require('ejs'),
    mail = require('./mail.js'),
    nodemailer = require('nodemailer'),
    path = require('path'),
    safe = require('safetydance'),
    settings = require('./settings.js'),
    translation = require('./translation.js'),
    smtpTransport = require('nodemailer-smtp-transport');

const NOOP_CALLBACK = function (error) { if (error) debug(error); };

const MAIL_TEMPLATES_DIR = path.join(__dirname, 'mail_templates');

// This will collect the most common details required for notification emails
function getMailConfig(callback) {
    assert.strictEqual(typeof callback, 'function');

    settings.getCloudronName(function (error, cloudronName) {
        if (error) debug('Error getting cloudron name: ', error);

        settings.getSupportConfig(function (error, supportConfig) {
            if (error) debug('Error getting support config: ', error);

            callback(null, {
                cloudronName: cloudronName || '',
                notificationFrom: `"${cloudronName}" <no-reply@${settings.dashboardDomain()}>`,
                supportEmail: supportConfig.email
            });
        });
    });
}

function sendMail(mailOptions, callback) {
    assert.strictEqual(typeof mailOptions, 'object');
    callback = callback || NOOP_CALLBACK;

    if (process.env.BOX_ENV === 'test') {
        exports._mailQueue.push(mailOptions);
        return callback();
    }

    mail.getMailAuth(function (error, data) {
        if (error) return callback(error);

        var transport = nodemailer.createTransport(smtpTransport({
            host: data.ip,
            port: data.port,
            auth: {
                user: mailOptions.authUser || `no-reply@${settings.dashboardDomain()}`,
                pass: data.relayToken
            }
        }));

        transport.sendMail(mailOptions, function (error) {
            if (error) return callback(new BoxError(BoxError.EXTERNAL_ERROR, error));

            debug(`Email "${mailOptions.subject}" sent to ${mailOptions.to}`);

            callback(null);
        });
    });
}

function render(templateFile, params, translationAssets) {
    assert.strictEqual(typeof templateFile, 'string');
    assert.strictEqual(typeof params, 'object');

    var content = null;
    var raw = safe.fs.readFileSync(path.join(MAIL_TEMPLATES_DIR, templateFile), 'utf8');
    if (raw === null) {
        debug(`Error loading ${templateFile}`);
        return '';
    }

    if (typeof translationAssets === 'object') raw = translation.translate(raw, translationAssets.translations || {}, translationAssets.fallback || {});

    try {
        content = ejs.render(raw, params);
    } catch (e) {
        debug(`Error rendering ${templateFile}`, e);
    }

    return content;
}

function sendInvite(user, invitor, inviteLink) {
    assert.strictEqual(typeof user, 'object');
    assert.strictEqual(typeof invitor, 'object');
    assert.strictEqual(typeof inviteLink, 'string');

    debug('Sending invite mail');

    getMailConfig(function (error, mailConfig) {
        if (error) return debug('Error getting mail details:', error);

        translation.getTranslations(function (error, translationAssets) {
            if (error) return debug('Error getting translations:', error);

            var templateData = {
                user: user.displayName || user.username || user.email,
                webadminUrl: settings.dashboardOrigin(),
                inviteLink: inviteLink,
                invitor: invitor ? invitor.email : null,
                cloudronName: mailConfig.cloudronName,
                cloudronAvatarUrl: settings.dashboardOrigin() + '/api/v1/cloudron/avatar'
            };

            var mailOptions = {
                from: mailConfig.notificationFrom,
                to: user.fallbackEmail,
                subject: ejs.render(translation.translate('{{ welcomeEmail.subject }}', translationAssets.translations || {}, translationAssets.fallback || {}), { cloudron: mailConfig.cloudronName }),
                text: render('welcome_user-text.ejs', templateData, translationAssets),
                html: render('welcome_user-html.ejs', templateData, translationAssets)
            };

            sendMail(mailOptions);
        });
    });
}

function sendNewLoginLocation(user, loginLocation) {
    assert.strictEqual(typeof user, 'object');
    assert.strictEqual(typeof loginLocation, 'object');

    const { ip, userAgent, country, city } = loginLocation;

    assert.strictEqual(typeof ip, 'string');
    assert.strictEqual(typeof userAgent, 'string');
    assert.strictEqual(typeof country, 'string');
    assert.strictEqual(typeof city, 'string');

    debug('Sending new login location mail');

    getMailConfig(function (error, mailConfig) {
        if (error) return debug('Error getting mail details:', error);

        translation.getTranslations(function (error, translationAssets) {
            if (error) return debug('Error getting translations:', error);

            const templateData = {
                user: user.displayName || user.username || user.email,
                ip,
                userAgent: userAgent || 'unknown',
                country,
                city,
                cloudronName: mailConfig.cloudronName,
                cloudronAvatarUrl: settings.dashboardOrigin() + '/api/v1/cloudron/avatar'
            };

            const mailOptions = {
                from: mailConfig.notificationFrom,
                to: user.fallbackEmail,
                subject: `[${mailConfig.cloudronName}] New login on your account`,
                text: render('new_login_location-text.ejs', templateData, translationAssets),
                html: render('new_login_location-html.ejs', templateData, translationAssets)
            };

            sendMail(mailOptions);
        });
    });
}

function passwordReset(user) {
    assert.strictEqual(typeof user, 'object');

    debug('Sending mail for password reset for user %s.', user.email, user.id);

    getMailConfig(function (error, mailConfig) {
        if (error) return debug('Error getting mail details:', error);

        translation.getTranslations(function (error, translationAssets) {
            if (error) return debug('Error getting translations:', error);

            var templateData = {
                user: user.displayName || user.username || user.email,
                resetLink: `${settings.dashboardOrigin()}/login.html?resetToken=${user.resetToken}`,
                cloudronName: mailConfig.cloudronName,
                cloudronAvatarUrl: settings.dashboardOrigin() + '/api/v1/cloudron/avatar'
            };

            var mailOptions = {
                from: mailConfig.notificationFrom,
                to: user.fallbackEmail,
                subject: ejs.render(translation.translate('{{ passwordResetEmail.subject }}', translationAssets.translations || {}, translationAssets.fallback || {}), { cloudron: mailConfig.cloudronName }),
                text: render('password_reset-text.ejs', templateData, translationAssets),
                html: render('password_reset-html.ejs', templateData, translationAssets)
            };

            sendMail(mailOptions);
        });
    });
}

function backupFailed(mailTo, errorMessage, logUrl, callback) {
    assert.strictEqual(typeof mailTo, 'string');
    assert.strictEqual(typeof errorMessage, 'string');
    assert.strictEqual(typeof logUrl, 'string');
    assert(typeof callback === 'undefined' || typeof callback ==='function');

    getMailConfig(function (error, mailConfig) {
        if (error) return debug('Error getting mail details:', error);

        var mailOptions = {
            from: mailConfig.notificationFrom,
            to: mailTo,
            subject: `[${mailConfig.cloudronName}] Failed to backup`,
            text: render('backup_failed.ejs', { cloudronName: mailConfig.cloudronName, message: errorMessage, logUrl, format: 'text' })
        };

        sendMail(mailOptions, callback);
    });
}

function certificateRenewalError(mailTo, domain, message, callback) {
    assert.strictEqual(typeof mailTo, 'string');
    assert.strictEqual(typeof domain, 'string');
    assert.strictEqual(typeof message, 'string');
    assert(typeof callback === 'undefined' || typeof callback ==='function');

    getMailConfig(function (error, mailConfig) {
        if (error) return debug('Error getting mail details:', error);

        const mailOptions = {
            from: mailConfig.notificationFrom,
            to: mailTo,
            subject: `[${mailConfig.cloudronName}] Certificate renewal error`,
            text: render('certificate_renewal_error.ejs', { domain: domain, message: message, format: 'text' })
        };

        sendMail(mailOptions, callback);
    });
}

function sendTestMail(domain, email, callback) {
    assert.strictEqual(typeof domain, 'string');
    assert.strictEqual(typeof email, 'string');
    assert.strictEqual(typeof callback, 'function');

    getMailConfig(function (error, mailConfig) {
        if (error) return debug('Error getting mail details:', error);

        var mailOptions = {
            authUser: `no-reply@${domain}`,
            from: `"${mailConfig.cloudronName}" <no-reply@${domain}>`,
            to: email,
            subject: `[${mailConfig.cloudronName}] Test Email`,
            text: render('test.ejs', { cloudronName: mailConfig.cloudronName, format: 'text'})
        };

        sendMail(mailOptions, callback);
    });
}