hyperzlib
/
nodebb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

style

Browse Source
v1.18.x
Barış Soner Uşaklı 8 years ago
parent 8e31ec7199
commit 6a742ead38
2 changed files with 241 additions and 240 deletions
Show Stats Download Patch File Download Diff File

254
src/emailer.js
Unescape Escape View File

@ -23,146 +23,146 @@ var transports = {
var app; var app;
var fallbackTransport; var fallbackTransport;
(function (Emailer) { var Emailer = module.exports;
Emailer.registerApp = function (expressApp) {
app = expressApp;
// Enable Gmail transport if enabled in ACP
if (parseInt(meta.config['email:GmailTransport:enabled'], 10) === 1) {
transports.gmail = nodemailer.createTransport(smtpTransport({
host: 'smtp.gmail.com',
port: 465,
secure: true,
auth: {
user: meta.config['email:GmailTransport:user'],
pass: meta.config['email:GmailTransport:pass'],
},
}));
fallbackTransport = transports.gmail;
} else {
fallbackTransport = transports.sendmail;
}
return Emailer;
};
Emailer.send = function (template, uid, params, callback) { Emailer.registerApp = function (expressApp) {
callback = callback || function () {}; app = expressApp;
if (!app) {
winston.warn('[emailer] App not ready!');
return callback();
}
async.waterfall([ // Enable Gmail transport if enabled in ACP
function (next) { if (parseInt(meta.config['email:GmailTransport:enabled'], 10) === 1) {
async.parallel({ transports.gmail = nodemailer.createTransport(smtpTransport({
email: async.apply(User.getUserField, uid, 'email'), host: 'smtp.gmail.com',
settings: async.apply(User.getSettings, uid), port: 465,
}, next); secure: true,
}, auth: {
function (results, next) { user: meta.config['email:GmailTransport:user'],
if (!results.email) { pass: meta.config['email:GmailTransport:pass'],
winston.warn('uid : ' + uid + ' has no email, not sending.');
return next();
}
params.uid = uid;
Emailer.sendToEmail(template, results.email, results.settings.userLang, params, next);
},
], callback);
};
Emailer.sendToEmail = function (template, email, language, params, callback) {
callback = callback || function () {};
var lang = language || meta.config.defaultLang || 'en-GB';
async.waterfall([
function (next) {
async.parallel({
html: function (next) {
renderAndTranslate('emails/' + template, params, lang, next);
},
subject: function (next) {
translator.translate(params.subject, lang, function (translated) {
next(null, translated);
});
},
}, next);
},
function (results, next) {
var data = {
_raw: params,
to: email,
from: meta.config['email:from'] || 'no-reply@' + getHostname(),
from_name: meta.config['email:from_name'] || 'NodeBB',
subject: results.subject,
html: results.html,
plaintext: htmlToText.fromString(results.html, {
ignoreImage: true,
}),
template: template,
uid: params.uid,
pid: params.pid,
fromUid: params.fromUid,
};
Plugins.fireHook('filter:email.modify', data, next);
},
function (data, next) {
if (Plugins.hasListeners('filter:email.send')) {
Plugins.fireHook('filter:email.send', data, next);
} else {
Emailer.sendViaFallback(data, next);
}
}, },
], function (err) { }));
if (err && err.code === 'ENOENT') { fallbackTransport = transports.gmail;
callback(new Error('[[error:sendmail-not-found]]')); } else {
} else { fallbackTransport = transports.sendmail;
callback(err); }
}
});
};
Emailer.sendViaFallback = function (data, callback) { return Emailer;
// Some minor alterations to the data to conform to nodemailer standard };
data.text = data.plaintext;
delete data.plaintext;
// NodeMailer uses a combined "from" Emailer.send = function (template, uid, params, callback) {
data.from = data.from_name + '<' + data.from + '>'; callback = callback || function () {};
delete data.from_name; if (!app) {
winston.warn('[emailer] App not ready!');
return callback();
}
winston.verbose('[emailer] Sending email to uid ' + data.uid + ' (' + data.to + ')'); async.waterfall([
fallbackTransport.sendMail(data, function (err) { function (next) {
if (err) { async.parallel({
winston.error(err); email: async.apply(User.getUserField, uid, 'email'),
settings: async.apply(User.getSettings, uid),
}, next);
},
function (results, next) {
if (!results.email) {
winston.warn('uid : ' + uid + ' has no email, not sending.');
return next();
} }
callback(); params.uid = uid;
}); Emailer.sendToEmail(template, results.email, results.settings.userLang, params, next);
}; },
], callback);
};
function render(tpl, params, next) { Emailer.sendToEmail = function (template, email, language, params, callback) {
if (meta.config['email:custom:' + tpl.replace('emails/', '')]) { callback = callback || function () {};
var text = templates.parse(meta.config['email:custom:' + tpl.replace('emails/', '')], params);
next(null, text); var lang = language || meta.config.defaultLang || 'en-GB';
async.waterfall([
function (next) {
async.parallel({
html: function (next) {
renderAndTranslate('emails/' + template, params, lang, next);
},
subject: function (next) {
translator.translate(params.subject, lang, function (translated) {
next(null, translated);
});
},
}, next);
},
function (results, next) {
var data = {
_raw: params,
to: email,
from: meta.config['email:from'] || 'no-reply@' + getHostname(),
from_name: meta.config['email:from_name'] || 'NodeBB',
subject: results.subject,
html: results.html,
plaintext: htmlToText.fromString(results.html, {
ignoreImage: true,
}),
template: template,
uid: params.uid,
pid: params.pid,
fromUid: params.fromUid,
};
Plugins.fireHook('filter:email.modify', data, next);
},
function (data, next) {
if (Plugins.hasListeners('filter:email.send')) {
Plugins.fireHook('filter:email.send', data, next);
} else {
Emailer.sendViaFallback(data, next);
}
},
], function (err) {
if (err && err.code === 'ENOENT') {
callback(new Error('[[error:sendmail-not-found]]'));
} else { } else {
app.render(tpl, params, next); callback(err);
} }
} });
};
function renderAndTranslate(tpl, params, lang, callback) { Emailer.sendViaFallback = function (data, callback) {
render(tpl, params, function (err, html) { // Some minor alterations to the data to conform to nodemailer standard
translator.translate(html, lang, function (translated) { data.text = data.plaintext;
callback(err, translated); delete data.plaintext;
});
});
}
function getHostname() { // NodeMailer uses a combined "from"
var configUrl = nconf.get('url'); data.from = data.from_name + '<' + data.from + '>';
var parsed = url.parse(configUrl); delete data.from_name;
winston.verbose('[emailer] Sending email to uid ' + data.uid + ' (' + data.to + ')');
fallbackTransport.sendMail(data, function (err) {
if (err) {
winston.error(err);
}
callback();
});
};
return parsed.hostname; function render(tpl, params, next) {
if (meta.config['email:custom:' + tpl.replace('emails/', '')]) {
var text = templates.parse(meta.config['email:custom:' + tpl.replace('emails/', '')], params);
next(null, text);
} else {
app.render(tpl, params, next);
} }
}(module.exports)); }
function renderAndTranslate(tpl, params, lang, callback) {
render(tpl, params, function (err, html) {
translator.translate(html, lang, function (translated) {
callback(err, translated);
});
});
}
function getHostname() {
var configUrl = nconf.get('url');
var parsed = url.parse(configUrl);
return parsed.hostname;
}

227
src/events.js
Unescape Escape View File

@ -9,94 +9,95 @@ var batch = require('./batch');
var user = require('./user'); var user = require('./user');
var utils = require('./utils'); var utils = require('./utils');
(function (events) { var events = module.exports;
events.log = function (data, callback) {
callback = callback || function () {}; events.log = function (data, callback) {
callback = callback || function () {};
async.waterfall([
function (next) { async.waterfall([
db.incrObjectField('global', 'nextEid', next); function (next) {
}, db.incrObjectField('global', 'nextEid', next);
function (eid, next) { },
data.timestamp = Date.now(); function (eid, next) {
data.eid = eid; data.timestamp = Date.now();
data.eid = eid;
async.parallel([
function (next) { async.parallel([
db.sortedSetAdd('events:time', data.timestamp, eid, next); function (next) {
}, db.sortedSetAdd('events:time', data.timestamp, eid, next);
function (next) { },
db.setObject('event:' + eid, data, next); function (next) {
}, db.setObject('event:' + eid, data, next);
], next); },
}, ], next);
], function (err) { },
callback(err); ], function (err) {
}); callback(err);
}; });
};
events.getEvents = function (start, stop, callback) {
async.waterfall([ events.getEvents = function (start, stop, callback) {
function (next) { async.waterfall([
db.getSortedSetRevRange('events:time', start, stop, next); function (next) {
}, db.getSortedSetRevRange('events:time', start, stop, next);
function (eids, next) { },
var keys = eids.map(function (eid) { function (eids, next) {
return 'event:' + eid; var keys = eids.map(function (eid) {
}); return 'event:' + eid;
db.getObjects(keys, next); });
}, db.getObjects(keys, next);
function (eventsData, next) { },
eventsData = eventsData.filter(Boolean); function (eventsData, next) {
addUserData(eventsData, 'uid', 'user', next); eventsData = eventsData.filter(Boolean);
}, addUserData(eventsData, 'uid', 'user', next);
function (eventsData, next) { },
addUserData(eventsData, 'targetUid', 'targetUser', next); function (eventsData, next) {
}, addUserData(eventsData, 'targetUid', 'targetUser', next);
function (eventsData, next) { },
eventsData.forEach(function (event) { function (eventsData, next) {
Object.keys(event).forEach(function (key) { eventsData.forEach(function (event) {
if (typeof event[key] === 'string') { Object.keys(event).forEach(function (key) {
event[key] = validator.escape(String(event[key] || '')); if (typeof event[key] === 'string') {
} event[key] = validator.escape(String(event[key] || ''));
}); }
var e = utils.merge(event);
e.eid = undefined;
e.uid = undefined;
e.type = undefined;
e.ip = undefined;
e.user = undefined;
event.jsonString = JSON.stringify(e, null, 4);
event.timestampISO = new Date(parseInt(event.timestamp, 10)).toUTCString();
}); });
next(null, eventsData); var e = utils.merge(event);
}, e.eid = undefined;
], callback); e.uid = undefined;
}; e.type = undefined;
e.ip = undefined;
function addUserData(eventsData, field, objectName, callback) { e.user = undefined;
var uids = eventsData.map(function (event) { event.jsonString = JSON.stringify(e, null, 4);
return event && event[field]; event.timestampISO = new Date(parseInt(event.timestamp, 10)).toUTCString();
}).filter(function (uid, index, array) { });
return uid && array.indexOf(uid) === index; next(null, eventsData);
}); },
], callback);
if (!uids.length) { };
return callback(null, eventsData);
} function addUserData(eventsData, field, objectName, callback) {
var uids = eventsData.map(function (event) {
async.parallel({ return event && event[field];
isAdmin: function (next) { }).filter(function (uid, index, array) {
user.isAdministrator(uids, next); return uid && array.indexOf(uid) === index;
}, });
userData: function (next) {
user.getUsersFields(uids, ['username', 'userslug', 'picture'], next); if (!uids.length) {
}, return callback(null, eventsData);
}, function (err, results) { }
if (err) {
return callback(err);
}
async.waterfall([
function (next) {
async.parallel({
isAdmin: function (next) {
user.isAdministrator(uids, next);
},
userData: function (next) {
user.getUsersFields(uids, ['username', 'userslug', 'picture'], next);
},
}, next);
},
function (results, next) {
var userData = results.userData; var userData = results.userData;
var map = {}; var map = {};
@ -110,30 +111,30 @@ var utils = require('./utils');
event[objectName] = map[event[field]]; event[objectName] = map[event[field]];
} }
}); });
callback(null, eventsData); next(null, eventsData);
}); },
} ], callback);
}
events.deleteEvents = function (eids, callback) {
callback = callback || function () {}; events.deleteEvents = function (eids, callback) {
async.parallel([ callback = callback || function () {};
function (next) { async.parallel([
var keys = eids.map(function (eid) { function (next) {
return 'event:' + eid; var keys = eids.map(function (eid) {
}); return 'event:' + eid;
db.deleteAll(keys, next); });
}, db.deleteAll(keys, next);
function (next) { },
db.sortedSetRemove('events:time', eids, next); function (next) {
}, db.sortedSetRemove('events:time', eids, next);
], callback); },
}; ], callback);
};
events.deleteAll = function (callback) {
callback = callback || function () {}; events.deleteAll = function (callback) {
callback = callback || function () {};
batch.processSortedSet('events:time', function (eids, next) {
events.deleteEvents(eids, next); batch.processSortedSet('events:time', function (eids, next) {
}, { alwaysStartAt: 0 }, callback); events.deleteEvents(eids, next);
}; }, { alwaysStartAt: 0 }, callback);
}(module.exports)); };

Write Preview
Loading…
Cancel
Save