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

feat: convert src/messaging/* to async/await (#7778)

Browse Source 
* feat: src/messaging/create.js, #7743

* feat: src/messaging/data.js, #7743

* feat: src/messaging/delete.js, #7743

* feat: src/messaging/edit.js, index.js, #7743

* fix: added in missing awaits

* feat: wrapped up src/messaging/* rewrite

* refactor: messaging delete/restore similar blocks of code
v1.18.x
Julian Lam 6 years ago committed by GitHub
parent fcf8fd51cb
commit 756a717eb8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 525 additions and 797 deletions
Show Stats Download Patch File Download Diff File

131
src/messaging/create.js
Unescape Escape View File

@ -1,70 +1,41 @@
'use strict'; 'use strict';
var async = require('async');
var meta = require('../meta'); var meta = require('../meta');
var plugins = require('../plugins'); var plugins = require('../plugins');
var db = require('../database'); var db = require('../database');
var user = require('../user'); var user = require('../user');
module.exports = function (Messaging) { module.exports = function (Messaging) {
Messaging.sendMessage = function (data, callback) { Messaging.sendMessage = async (data) => {
async.waterfall([ await Messaging.checkContent(data.content);
function (next) { const inRoom = await Messaging.isUserInRoom(data.uid, data.roomId);
Messaging.checkContent(data.content, next);
},
function (next) {
Messaging.isUserInRoom(data.uid, data.roomId, next);
},
function (inRoom, next) {
if (!inRoom) { if (!inRoom) {
return next(new Error('[[error:not-allowed]]')); throw new Error('[[error:not-allowed]]');
} }
Messaging.addMessage(data, next); return await Messaging.addMessage(data);
},
], callback);
}; };
Messaging.checkContent = function (content, callback) { Messaging.checkContent = async (content) => {
if (!content) { if (!content) {
return callback(new Error('[[error:invalid-chat-message]]')); throw new Error('[[error:invalid-chat-message]]');
}
plugins.fireHook('filter:messaging.checkContent', { content: content }, function (err, data) {
if (err) {
return callback(err);
} }
const maximumChatMessageLength = (meta.config.maximumChatMessageLength || 1000);
const data = await plugins.fireHook('filter:messaging.checkContent', { content: content });
content = String(data.content).trim(); content = String(data.content).trim();
if (!content) { if (!content) {
return callback(new Error('[[error:invalid-chat-message]]')); throw new Error('[[error:invalid-chat-message]]');
} }
var maximumChatMessageLength = (meta.config.maximumChatMessageLength || 1000);
if (content.length > maximumChatMessageLength) { if (content.length > maximumChatMessageLength) {
return callback(new Error('[[error:chat-message-too-long, ' + maximumChatMessageLength + ']]')); throw new Error('[[error:chat-message-too-long, ' + maximumChatMessageLength + ']]');
} }
callback();
});
}; };
Messaging.addMessage = function (data, callback) { Messaging.addMessage = async (data) => {
var mid; const mid = await db.incrObjectField('global', 'nextMid');
var message;
var isNewSet;
const timestamp = data.timestamp || new Date().getTime(); const timestamp = data.timestamp || new Date().getTime();
let message = {
async.waterfall([
function (next) {
Messaging.checkContent(data.content, next);
},
function (next) {
db.incrObjectField('global', 'nextMid', next);
},
function (_mid, next) {
mid = _mid;
message = {
content: String(data.content), content: String(data.content),
timestamp: timestamp, timestamp: timestamp,
fromuid: data.uid, fromuid: data.uid,
@ -72,49 +43,36 @@ module.exports = function (Messaging) {
deleted: 0, deleted: 0,
system: data.system || 0, system: data.system || 0,
}; };
if (data.ip) { if (data.ip) {
message.ip = data.ip; message.ip = data.ip;
} }
plugins.fireHook('filter:messaging.save', message, next); message = await plugins.fireHook('filter:messaging.save', message);
}, await db.setObject('message:' + mid, message);
function (message, next) { const isNewSet = await Messaging.isNewSet(data.uid, data.roomId, timestamp);
db.setObject('message:' + mid, message, next); let uids = await db.getSortedSetRange('chat:room:' + data.roomId + ':uids', 0, -1);
}, uids = await user.blocks.filterUids(data.uid, uids);
function (next) {
Messaging.isNewSet(data.uid, data.roomId, timestamp, next); await Promise.all([
}, Messaging.addRoomToUsers(data.roomId, uids, timestamp),
function (_isNewSet, next) { Messaging.addMessageToUsers(data.roomId, uids, mid, timestamp),
isNewSet = _isNewSet; Messaging.markUnread(uids, data.roomId),
db.getSortedSetRange('chat:room:' + data.roomId + ':uids', 0, -1, next); ]);
},
function (uids, next) { const [, messages] = await Promise.all([
user.blocks.filterUids(data.uid, uids, next); await Messaging.markRead(data.uid, data.roomId),
}, await Messaging.getMessagesData([mid], data.uid, data.roomId, true),
function (uids, next) { ]);
async.parallel([
async.apply(Messaging.addRoomToUsers, data.roomId, uids, timestamp), if (!messages || !messages[0]) {
async.apply(Messaging.addMessageToUsers, data.roomId, uids, mid, timestamp), return null;
async.apply(Messaging.markUnread, uids, data.roomId),
], next);
},
function (results, next) {
async.parallel({
markRead: async.apply(Messaging.markRead, data.uid, data.roomId),
messages: async.apply(Messaging.getMessagesData, [mid], data.uid, data.roomId, true),
}, next);
},
function (results, next) {
if (!results.messages || !results.messages[0]) {
return next(null, null);
} }
results.messages[0].newSet = isNewSet; messages[0].newSet = isNewSet;
results.messages[0].mid = mid; messages[0].mid = mid;
results.messages[0].roomId = data.roomId; messages[0].roomId = data.roomId;
next(null, results.messages[0]); return messages[0];
},
], callback);
}; };
Messaging.addSystemMessage = async (content, uid, roomId) => { Messaging.addSystemMessage = async (content, uid, roomId) => {
@ -127,19 +85,20 @@ module.exports = function (Messaging) {
Messaging.notifyUsersInRoom(uid, roomId, message); Messaging.notifyUsersInRoom(uid, roomId, message);
}; };
Messaging.addRoomToUsers = function (roomId, uids, timestamp, callback) { Messaging.addRoomToUsers = async (roomId, uids, timestamp) => {
if (!uids.length) { if (!uids.length) {
return callback(); return;
} }
const keys = uids.map(uid => 'uid:' + uid + ':chat:rooms'); const keys = uids.map(uid => 'uid:' + uid + ':chat:rooms');
db.sortedSetsAdd(keys, timestamp, roomId, callback); await db.sortedSetsAdd(keys, timestamp, roomId);
}; };
Messaging.addMessageToUsers = function (roomId, uids, mid, timestamp, callback) { Messaging.addMessageToUsers = async (roomId, uids, mid, timestamp) => {
if (!uids.length) { if (!uids.length) {
return callback(); return;
} }
const keys = uids.map(uid => 'uid:' + uid + ':chat:room:' + roomId + ':mids'); const keys = uids.map(uid => 'uid:' + uid + ':chat:room:' + roomId + ':mids');
db.sortedSetsAdd(keys, timestamp, mid, callback); await db.sortedSetsAdd(keys, timestamp, mid);
}; };
}; };

123
src/messaging/data.js
Unescape Escape View File

@ -1,7 +1,5 @@
'use strict'; 'use strict';
var async = require('async');
var db = require('../database'); var db = require('../database');
var user = require('../user'); var user = require('../user');
var utils = require('../utils'); var utils = require('../utils');
@ -12,69 +10,59 @@ const intFields = ['timestamp', 'edited', 'fromuid', 'roomId', 'deleted', 'syste
module.exports = function (Messaging) { module.exports = function (Messaging) {
Messaging.newMessageCutoff = 1000 * 60 * 3; Messaging.newMessageCutoff = 1000 * 60 * 3;
Messaging.getMessagesFields = function (mids, fields, callback) { Messaging.getMessagesFields = async (mids, fields) => {
if (!Array.isArray(mids) || !mids.length) { if (!Array.isArray(mids) || !mids.length) {
return callback(null, []); return [];
} }
async.waterfall([
function (next) {
const keys = mids.map(mid => 'message:' + mid); const keys = mids.map(mid => 'message:' + mid);
let messages;
if (fields.length) { if (fields.length) {
db.getObjectsFields(keys, fields, next); messages = await db.getObjectsFields(keys, fields);
} else { } else {
db.getObjects(keys, next); messages = await db.getObjects(keys);
} }
},
function (messages, next) {
messages.forEach(message => modifyMessage(message, fields)); messages.forEach(message => modifyMessage(message, fields));
next(null, messages); return messages;
},
], callback);
}; };
Messaging.getMessageField = function (mid, field, callback) { Messaging.getMessageField = async (mid, field) => {
Messaging.getMessageFields(mid, [field], function (err, fields) { const fields = await Messaging.getMessageFields(mid, [field]);
callback(err, fields ? fields[field] : null); return fields ? fields[field] : null;
});
}; };
Messaging.getMessageFields = function (mid, fields, callback) { Messaging.getMessageFields = async (mid, fields) => {
Messaging.getMessagesFields([mid], fields, function (err, messages) { const messages = await Messaging.getMessagesFields([mid], fields);
callback(err, messages ? messages[0] : null); return messages ? messages[0] : null;
});
}; };
Messaging.setMessageField = function (mid, field, content, callback) { Messaging.setMessageField = async (mid, field, content) => {
db.setObjectField('message:' + mid, field, content, callback); await db.setObjectField('message:' + mid, field, content);
}; };
Messaging.setMessageFields = function (mid, data, callback) { Messaging.setMessageFields = async (mid, data) => {
db.setObject('message:' + mid, data, callback); await db.setObject('message:' + mid, data);
}; };
Messaging.getMessagesData = function (mids, uid, roomId, isNew, callback) { Messaging.getMessagesData = async (mids, uid, roomId, isNew) => {
var messages; let messages = await Messaging.getMessagesFields(mids, []);
messages = await user.blocks.filter(uid, 'fromuid', messages);
async.waterfall([ messages = messages
function (next) { .map(function (msg, idx) {
Messaging.getMessagesFields(mids, [], next);
},
async.apply(user.blocks.filter, uid, 'fromuid'),
function (_messages, next) {
messages = _messages.map(function (msg, idx) {
if (msg) { if (msg) {
msg.messageId = parseInt(mids[idx], 10); msg.messageId = parseInt(mids[idx], 10);
msg.ip = undefined; msg.ip = undefined;
} }
return msg; return msg;
}).filter(Boolean); })
.filter(Boolean);
const uids = messages.map(msg => msg && msg.fromuid); const users = await user.getUsersFields(
messages.map(msg => msg && msg.fromuid),
['uid', 'username', 'userslug', 'picture', 'status', 'banned']
);
user.getUsersFields(uids, ['uid', 'username', 'userslug', 'picture', 'status', 'banned'], next);
},
function (users, next) {
messages.forEach(function (message, index) { messages.forEach(function (message, index) {
message.fromUser = users[index]; message.fromUser = users[index];
message.fromUser.banned = !!message.fromUser.banned; message.fromUser.banned = !!message.fromUser.banned;
@ -89,22 +77,17 @@ module.exports = function (Messaging) {
message.system = !!message.system; message.system = !!message.system;
}); });
async.map(messages, function (message, next) { messages = await Promise.all(messages.map(async (message) => {
if (message.system) { if (message.system) {
return setImmediate(next, null, message); return message;
} }
Messaging.parse(message.content, message.fromuid, uid, roomId, isNew, function (err, result) { const result = await Messaging.parse(message.content, message.fromuid, uid, roomId, isNew);
if (err) {
return next(err);
}
message.content = result; message.content = result;
message.cleanedContent = utils.stripHTMLTags(utils.decodeHTMLEntities(result)); message.cleanedContent = utils.stripHTMLTags(utils.decodeHTMLEntities(result));
next(null, message); return message;
}); }));
}, next);
},
function (messages, next) {
if (messages.length > 1) { if (messages.length > 1) {
// Add a spacer in between messages with time gaps between them // Add a spacer in between messages with time gaps between them
messages = messages.map(function (message, index) { messages = messages.map(function (message, index) {
@ -119,50 +102,34 @@ module.exports = function (Messaging) {
return message; return message;
}); });
next(undefined, messages);
} else if (messages.length === 1) { } else if (messages.length === 1) {
// For single messages, we don't know the context, so look up the previous message and compare // For single messages, we don't know the context, so look up the previous message and compare
var key = 'uid:' + uid + ':chat:room:' + roomId + ':mids'; var key = 'uid:' + uid + ':chat:room:' + roomId + ':mids';
async.waterfall([ const index = await db.sortedSetRank(key, messages[0].messageId);
async.apply(db.sortedSetRank, key, messages[0].messageId),
function (index, next) {
// Continue only if this isn't the first message in sorted set
if (index > 0) { if (index > 0) {
db.getSortedSetRange(key, index - 1, index - 1, next); const mid = await db.getSortedSetRange(key, index - 1, index - 1);
} else { const fields = await Messaging.getMessageFields(mid, ['fromuid', 'timestamp']);
messages[0].newSet = true;
return next(undefined, messages);
}
},
function (mid, next) {
Messaging.getMessageFields(mid, ['fromuid', 'timestamp'], next);
},
function (fields, next) {
if ((messages[0].timestamp > fields.timestamp + Messaging.newMessageCutoff) || if ((messages[0].timestamp > fields.timestamp + Messaging.newMessageCutoff) ||
(messages[0].fromuid !== fields.fromuid)) { (messages[0].fromuid !== fields.fromuid)) {
// If it's been 5 minutes, this is a new set of messages // If it's been 5 minutes, this is a new set of messages
messages[0].newSet = true; messages[0].newSet = true;
} }
next(null, messages);
},
], next);
} else { } else {
next(null, []); messages[0].newSet = true;
} }
}, } else {
function (messages, next) { messages = [];
plugins.fireHook('filter:messaging.getMessages', { }
const data = await plugins.fireHook('filter:messaging.getMessages', {
messages: messages, messages: messages,
uid: uid, uid: uid,
roomId: roomId, roomId: roomId,
isNew: isNew, isNew: isNew,
mids: mids, mids: mids,
}, function (err, data) {
next(err, data && data.messages);
}); });
},
], callback); return data && data.messages;
}; };
}; };

33
src/messaging/delete.js
Unescape Escape View File

@ -1,31 +1,16 @@
'use strict'; 'use strict';
var async = require('async');
module.exports = function (Messaging) { module.exports = function (Messaging) {
Messaging.deleteMessage = function (mid, roomId, callback) { Messaging.deleteMessage = async mid => await doDeleteRestore(mid, 1);
async.waterfall([ Messaging.restoreMessage = async mid => await doDeleteRestore(mid, 0);
async.apply(Messaging.getMessageField, mid, 'deleted'),
function (deleted, next) {
if (deleted) {
return next(new Error('[[error:chat-deleted-already]]'));
}
Messaging.setMessageField(mid, 'deleted', 1, next);
},
], callback);
};
Messaging.restoreMessage = function (mid, roomId, callback) { async function doDeleteRestore(mid, state) {
async.waterfall([ const field = state ? 'deleted' : 'restored';
async.apply(Messaging.getMessageField, mid, 'deleted'), const cur = await Messaging.getMessageField(mid, 'deleted');
function (deleted, next) { if (cur === state) {
if (!deleted) { throw new Error('[[error:chat-' + field + '-already]]');
return next(new Error('[[error:chat-restored-already]]'));
} }
Messaging.setMessageField(mid, 'deleted', 0, next); return await Messaging.setMessageField(mid, 'deleted', state);
}, }
], callback);
};
}; };

102
src/messaging/edit.js
Unescape Escape View File

@ -1,7 +1,5 @@
'use strict'; 'use strict';
var async = require('async');
var meta = require('../meta'); var meta = require('../meta');
var user = require('../user'); var user = require('../user');
@ -9,52 +7,34 @@ var sockets = require('../socket.io');
module.exports = function (Messaging) { module.exports = function (Messaging) {
Messaging.editMessage = function (uid, mid, roomId, content, callback) { Messaging.editMessage = async (uid, mid, roomId, content) => {
var uids; const raw = await Messaging.getMessageField(mid, 'content');
async.waterfall([
function (next) {
Messaging.getMessageField(mid, 'content', next);
},
function (raw, next) {
if (raw === content) { if (raw === content) {
return callback(); return;
} }
if (!String(content).trim()) { if (!String(content).trim()) {
return callback(new Error('[[error:invalid-chat-message]]')); throw new Error('[[error:invalid-chat-message]]');
} }
Messaging.setMessageFields(mid, { await Messaging.setMessageFields(mid, {
content: content, content: content,
edited: Date.now(), edited: Date.now(),
}, next); });
},
function (next) { // Propagate this change to users in the room
Messaging.getUidsInRoom(roomId, 0, -1, next); const [uids, messages] = await Promise.all([
}, Messaging.getUidsInRoom(roomId, 0, -1),
function (_uids, next) { Messaging.getMessagesData([mid], uid, roomId, true),
uids = _uids; ]);
Messaging.getMessagesData([mid], uid, roomId, true, next);
},
function (messages, next) {
uids.forEach(function (uid) { uids.forEach(function (uid) {
sockets.in('uid_' + uid).emit('event:chats.edit', { sockets.in('uid_' + uid).emit('event:chats.edit', {
messages: messages, messages: messages,
}); });
}); });
next();
},
], callback);
};
Messaging.canEdit = function (messageId, uid, callback) {
canEditDelete(messageId, uid, 'edit', callback);
};
Messaging.canDelete = function (messageId, uid, callback) {
canEditDelete(messageId, uid, 'delete', callback);
}; };
function canEditDelete(messageId, uid, type, callback) { const canEditDelete = async (messageId, uid, type) => {
var durationConfig = ''; let durationConfig = '';
if (type === 'edit') { if (type === 'edit') {
durationConfig = 'chatEditDuration'; durationConfig = 'chatEditDuration';
} else if (type === 'delete') { } else if (type === 'delete') {
@ -62,47 +42,39 @@ module.exports = function (Messaging) {
} }
if (meta.config.disableChat) { if (meta.config.disableChat) {
return callback(new Error('[[error:chat-disabled]]')); throw new Error('[[error:chat-disabled]]');
} else if (meta.config.disableChatMessageEditing) { } else if (meta.config.disableChatMessageEditing) {
return callback(new Error('[[error:chat-message-editing-disabled]]')); throw new Error('[[error:chat-message-editing-disabled]]');
} }
async.waterfall([ const userData = await user.getUserFields(uid, ['banned', 'email:confirmed']);
function (next) {
user.getUserFields(uid, ['banned', 'email:confirmed'], next);
},
function (userData, next) {
if (userData.banned) { if (userData.banned) {
return callback(new Error('[[error:user-banned]]')); throw new Error('[[error:user-banned]]');
} }
if (meta.config.requireEmailConfirmation && !userData['email:confirmed']) { if (meta.config.requireEmailConfirmation && !userData['email:confirmed']) {
return callback(new Error('[[error:email-not-confirmed]]')); throw new Error('[[error:email-not-confirmed]]');
} }
async.parallel({
isAdmin: function (next) { const [isAdmin, messageData] = await Promise.all([
user.isAdministrator(uid, next); user.isAdministrator(uid),
}, Messaging.getMessageFields(messageId, ['fromuid', 'timestamp']),
messageData: function (next) { ]);
Messaging.getMessageFields(messageId, ['fromuid', 'timestamp'], next);
}, if (isAdmin) {
}, next); return;
},
function (results, next) {
if (results.isAdmin) {
return callback();
} }
var chatConfigDuration = meta.config[durationConfig]; var chatConfigDuration = meta.config[durationConfig];
if (chatConfigDuration && Date.now() - results.messageData.timestamp > chatConfigDuration * 1000) { if (chatConfigDuration && Date.now() - messageData.timestamp > chatConfigDuration * 1000) {
return callback(new Error('[[error:chat-' + type + '-duration-expired, ' + meta.config[durationConfig] + ']]')); throw new Error('[[error:chat-' + type + '-duration-expired, ' + meta.config[durationConfig] + ']]');
} }
if (results.messageData.fromuid === parseInt(uid, 10)) { if (messageData.fromuid === parseInt(uid, 10)) {
return callback(); return;
} }
next(new Error('[[error:cant-' + type + '-chat-message]]')); throw new Error('[[error:cant-' + type + '-chat-message]]');
}, };
], callback);
} Messaging.canEdit = async (messageId, uid) => await canEditDelete(messageId, uid, 'edit');
Messaging.canDelete = async (messageId, uid) => await canEditDelete(messageId, uid, 'delete');
}; };

358
src/messaging/index.js
Unescape Escape View File

@ -1,16 +1,15 @@
'use strict'; 'use strict';
var async = require('async'); const validator = require('validator');
var validator = require('validator');
var db = require('../database'); const db = require('../database');
var user = require('../user'); const user = require('../user');
var plugins = require('../plugins'); const plugins = require('../plugins');
var meta = require('../meta'); const meta = require('../meta');
var utils = require('../utils'); const utils = require('../utils');
var Messaging = module.exports; const Messaging = module.exports;
require('./data')(Messaging); require('./data')(Messaging);
require('./create')(Messaging); require('./create')(Messaging);
@ -21,38 +20,27 @@ require('./unread')(Messaging);
require('./notifications')(Messaging); require('./notifications')(Messaging);
Messaging.getMessages = function (params, callback) { Messaging.getMessages = async (params) => {
var uid = params.uid; const isNew = params.isNew || false;
var roomId = params.roomId; const start = params.hasOwnProperty('start') ? params.start : 0;
var isNew = params.isNew || false; const stop = parseInt(start, 10) + ((params.count || 50) - 1);
var start = params.hasOwnProperty('start') ? params.start : 0;
var stop = parseInt(start, 10) + ((params.count || 50) - 1); const indices = {};
const ok = await canGet('filter:messaging.canGetMessages', params.callerUid, params.uid);
var indices = {}; if (!ok) {
async.waterfall([ return;
function (next) {
canGet('filter:messaging.canGetMessages', params.callerUid, params.uid, next);
},
function (canGet, next) {
if (!canGet) {
return callback(null, null);
} }
db.getSortedSetRevRange('uid:' + uid + ':chat:room:' + roomId + ':mids', start, stop, next);
}, const mids = await db.getSortedSetRevRange('uid:' + params.uid + ':chat:room:' + params.roomId + ':mids', start, stop);
function (mids, next) {
if (!mids.length) { if (!mids.length) {
return callback(null, []); return [];
} }
mids.forEach(function (mid, index) { mids.forEach(function (mid, index) {
indices[mid] = start + index; indices[mid] = start + index;
}); });
mids.reverse(); mids.reverse();
Messaging.getMessagesData(mids, uid, roomId, isNew, next); let messageData = await Messaging.getMessagesData(mids, params.uid, params.roomId, isNew);
},
function (messageData, next) {
messageData.forEach(function (messageData) { messageData.forEach(function (messageData) {
messageData.index = indices[messageData.messageId.toString()]; messageData.index = indices[messageData.messageId.toString()];
}); });
@ -62,28 +50,22 @@ Messaging.getMessages = function (params, callback) {
return (!messageData.deleted || messageData.fromuid === parseInt(params.uid, 10)); return (!messageData.deleted || messageData.fromuid === parseInt(params.uid, 10));
}); });
next(null, messageData); return messageData;
},
], callback);
}; };
function canGet(hook, callerUid, uid, callback) { async function canGet(hook, callerUid, uid) {
plugins.fireHook(hook, { const data = await plugins.fireHook(hook, {
callerUid: callerUid, callerUid: callerUid,
uid: uid, uid: uid,
canGet: parseInt(callerUid, 10) === parseInt(uid, 10), canGet: parseInt(callerUid, 10) === parseInt(uid, 10),
}, function (err, data) {
callback(err, data ? data.canGet : false);
}); });
}
Messaging.parse = function (message, fromuid, uid, roomId, isNew, callback) { return data ? data.canGet : false;
plugins.fireHook('filter:parse.raw', message, function (err, parsed) {
if (err) {
return callback(err);
} }
var messageData = { Messaging.parse = async (message, fromuid, uid, roomId, isNew) => {
const parsed = await plugins.fireHook('filter:parse.raw', message);
let messageData = {
message: message, message: message,
parsed: parsed, parsed: parsed,
fromuid: fromuid, fromuid: fromuid,
@ -93,70 +75,39 @@ Messaging.parse = function (message, fromuid, uid, roomId, isNew, callback) {
parsedMessage: parsed, parsedMessage: parsed,
}; };
plugins.fireHook('filter:messaging.parse', messageData, function (err, messageData) { messageData = await plugins.fireHook('filter:messaging.parse', messageData);
callback(err, messageData ? messageData.parsedMessage : ''); return messageData ? messageData.parsedMessage : '';
});
});
}; };
Messaging.isNewSet = function (uid, roomId, timestamp, callback) { Messaging.isNewSet = async (uid, roomId, timestamp) => {
var setKey = 'uid:' + uid + ':chat:room:' + roomId + ':mids'; const setKey = 'uid:' + uid + ':chat:room:' + roomId + ':mids';
const messages = await db.getSortedSetRevRangeWithScores(setKey, 0, 0);
async.waterfall([
function (next) {
db.getSortedSetRevRangeWithScores(setKey, 0, 0, next);
},
function (messages, next) {
if (messages && messages.length) { if (messages && messages.length) {
next(null, parseInt(timestamp, 10) > parseInt(messages[0].score, 10) + Messaging.newMessageCutoff); return parseInt(timestamp, 10) > parseInt(messages[0].score, 10) + Messaging.newMessageCutoff;
} else {
next(null, true);
} }
}, return true;
], callback);
}; };
Messaging.getRecentChats = async (callerUid, uid, start, stop) => {
Messaging.getRecentChats = function (callerUid, uid, start, stop, callback) { const ok = await canGet('filter:messaging.canGetRecentChats', callerUid, uid);
async.waterfall([ if (!ok) {
function (next) { return null;
canGet('filter:messaging.canGetRecentChats', callerUid, uid, next);
},
function (canGet, next) {
if (!canGet) {
return callback(null, null);
}
db.getSortedSetRevRange('uid:' + uid + ':chat:rooms', start, stop, next);
},
function (roomIds, next) {
async.parallel({
roomData: function (next) {
Messaging.getRoomsData(roomIds, next);
},
unread: function (next) {
db.isSortedSetMembers('uid:' + uid + ':chat:rooms:unread', roomIds, next);
},
users: function (next) {
async.map(roomIds, function (roomId, next) {
db.getSortedSetRevRange('chat:room:' + roomId + ':uids', 0, 9, function (err, uids) {
if (err) {
return next(err);
} }
const roomIds = await db.getSortedSetRevRange('uid:' + uid + ':chat:rooms', start, stop);
const results = await utils.promiseParallel({
roomData: Messaging.getRoomsData(roomIds),
unread: db.isSortedSetMembers('uid:' + uid + ':chat:rooms:unread', roomIds),
users: Promise.all(roomIds.map(async (roomId) => {
let uids = await db.getSortedSetRevRange('chat:room:' + roomId + ':uids', 0, 9);
uids = uids.filter(function (value) { uids = uids.filter(function (value) {
return value && parseInt(value, 10) !== parseInt(uid, 10); return value && parseInt(value, 10) !== parseInt(uid, 10);
}); });
user.getUsersFields(uids, ['uid', 'username', 'userslug', 'picture', 'status', 'lastonline'], next); return await user.getUsersFields(uids, ['uid', 'username', 'userslug', 'picture', 'status', 'lastonline']);
})),
teasers: Promise.all(roomIds.map(async roomId => Messaging.getTeaser(uid, roomId))),
}); });
}, next);
},
teasers: function (next) {
async.map(roomIds, function (roomId, next) {
Messaging.getTeaser(uid, roomId, next);
}, next);
},
}, next);
},
function (results, next) {
results.roomData.forEach(function (room, index) { results.roomData.forEach(function (room, index) {
if (room) { if (room) {
room.users = results.users[index]; room.users = results.users[index];
@ -179,21 +130,16 @@ Messaging.getRecentChats = function (callerUid, uid, start, stop, callback) {
}); });
results.roomData = results.roomData.filter(Boolean); results.roomData = results.roomData.filter(Boolean);
const ref = { rooms: results.roomData, nextStart: stop + 1 };
next(null, { rooms: results.roomData, nextStart: stop + 1 }); return await plugins.fireHook('filter:messaging.getRecentChats', {
},
function (ref, next) {
plugins.fireHook('filter:messaging.getRecentChats', {
rooms: ref.rooms, rooms: ref.rooms,
nextStart: ref.nextStart, nextStart: ref.nextStart,
uid: uid, uid: uid,
callerUid: callerUid, callerUid: callerUid,
}, next); });
},
], callback);
}; };
Messaging.generateUsernames = function (users, excludeUid) { Messaging.generateUsernames = (users, excludeUid) => {
users = users.filter(function (user) { users = users.filter(function (user) {
return user && parseInt(user.uid, 10) !== excludeUid; return user && parseInt(user.uid, 10) !== excludeUid;
}); });
@ -202,211 +148,149 @@ Messaging.generateUsernames = function (users, excludeUid) {
}).join(', '); }).join(', ');
}; };
Messaging.getTeaser = function (uid, roomId, callback) { Messaging.getTeaser = async (uid, roomId) => {
var teaser; const mid = await Messaging.getLatestUndeletedMessage(uid, roomId);
async.waterfall([
function (next) {
Messaging.getLatestUndeletedMessage(uid, roomId, next);
},
function (mid, next) {
if (!mid) { if (!mid) {
return callback(null, null); return null;
} }
Messaging.getMessageFields(mid, ['fromuid', 'content', 'timestamp'], next); const teaser = await Messaging.getMessageFields(mid, ['fromuid', 'content', 'timestamp']);
},
function (_teaser, next) {
teaser = _teaser;
if (!teaser.fromuid) { if (!teaser.fromuid) {
return callback(null, null); return null;
} }
user.blocks.is(teaser.fromuid, uid, next); const blocked = await user.blocks.is(teaser.fromuid, uid);
},
function (blocked, next) {
if (blocked) { if (blocked) {
return callback(null, null); return null;
} }
teaser.user = await user.getUserFields(teaser.fromuid, ['uid', 'username', 'userslug', 'picture', 'status', 'lastonline']);
if (teaser.content) { if (teaser.content) {
teaser.content = utils.stripHTMLTags(utils.decodeHTMLEntities(teaser.content)); teaser.content = utils.stripHTMLTags(utils.decodeHTMLEntities(teaser.content));
teaser.content = validator.escape(String(teaser.content)); teaser.content = validator.escape(String(teaser.content));
} }
teaser.timestampISO = utils.toISOString(teaser.timestamp); const payload = await plugins.fireHook('filter:messaging.getTeaser', { teaser: teaser });
user.getUserFields(teaser.fromuid, ['uid', 'username', 'userslug', 'picture', 'status', 'lastonline'], next); return payload.teaser;
},
function (user, next) {
teaser.user = user;
plugins.fireHook('filter:messaging.getTeaser', { teaser: teaser }, function (err, data) {
next(err, data.teaser);
});
},
], callback);
}; };
Messaging.getLatestUndeletedMessage = function (uid, roomId, callback) { Messaging.getLatestUndeletedMessage = async (uid, roomId) => {
var done = false; let done = false;
var latestMid = null; let latestMid = null;
var index = 0; let index = 0;
var mids; let mids;
async.doWhilst(
function (next) { while (!done) {
async.waterfall([ /* eslint-disable no-await-in-loop */
function (_next) { mids = await db.getSortedSetRevRange('uid:' + uid + ':chat:room:' + roomId + ':mids', index, index);
db.getSortedSetRevRange('uid:' + uid + ':chat:room:' + roomId + ':mids', index, index, _next); if (mids.length) {
}, const states = await Messaging.getMessageFields(mids[0], ['deleted', 'system']);
function (_mids, _next) {
mids = _mids;
if (!mids.length) {
done = true;
return next();
}
Messaging.getMessageFields(mids[0], ['deleted', 'system'], _next);
},
function (states, _next) {
done = !states.deleted && !states.system; done = !states.deleted && !states.system;
if (done) { if (done) {
latestMid = mids[0]; latestMid = mids[0];
} }
index += 1; index += 1;
_next(); } else {
}, done = true;
], next);
},
function (next) {
next(null, !done);
},
function (err) {
callback(err, parseInt(latestMid, 10));
} }
); }
return latestMid;
}; };
Messaging.canMessageUser = function (uid, toUid, callback) { Messaging.canMessageUser = async (uid, toUid) => {
if (meta.config.disableChat || uid <= 0 || uid === toUid) { if (meta.config.disableChat || uid <= 0 || uid === toUid) {
return callback(new Error('[[error:chat-disabled]]')); throw new Error('[[error:chat-disabled]]');
} }
if (parseInt(uid, 10) === parseInt(toUid, 10)) { if (parseInt(uid, 10) === parseInt(toUid, 10)) {
return callback(new Error('[[error:cant-chat-with-yourself')); throw new Error('[[error:cant-chat-with-yourself');
} }
async.waterfall([ const exists = await user.exists(toUid);
function (next) {
user.exists(toUid, next);
},
function (exists, next) {
if (!exists) { if (!exists) {
return callback(new Error('[[error:no-user]]')); throw new Error('[[error:no-user]]');
} }
user.getUserFields(uid, ['banned', 'email:confirmed'], next);
}, const userData = await user.getUserFields(uid, ['banned', 'email:confirmed']);
function (userData, next) {
if (userData.banned) { if (userData.banned) {
return callback(new Error('[[error:user-banned]]')); throw new Error('[[error:user-banned]]');
} }
if (meta.config.requireEmailConfirmation && !userData['email:confirmed']) { if (meta.config.requireEmailConfirmation && !userData['email:confirmed']) {
return callback(new Error('[[error:email-not-confirmed-chat]]')); throw new Error('[[error:email-not-confirmed-chat]]');
} }
async.parallel({ const results = await utils.promiseParallel({
settings: async.apply(user.getSettings, toUid), settings: user.getSettings(toUid),
isAdmin: async.apply(user.isAdministrator, uid), isAdmin: user.isAdministrator(uid),
isModerator: async.apply(user.isModeratorOfAnyCategory, uid), isModerator: user.isModeratorOfAnyCategory(uid),
isFollowing: async.apply(user.isFollowing, toUid, uid), isFollowing: user.isFollowing(toUid, uid),
}, next); });
},
function (results, next) {
if (results.settings.restrictChat && !results.isAdmin && !results.isModerator && !results.isFollowing) { if (results.settings.restrictChat && !results.isAdmin && !results.isModerator && !results.isFollowing) {
return next(new Error('[[error:chat-restricted]]')); throw new Error('[[error:chat-restricted]]');
} }
plugins.fireHook('static:messaging.canMessageUser', { await plugins.fireHook('static:messaging.canMessageUser', {
uid: uid, uid: uid,
toUid: toUid, toUid: toUid,
}, function (err) {
next(err);
}); });
},
], callback);
}; };
Messaging.canMessageRoom = function (uid, roomId, callback) { Messaging.canMessageRoom = async (uid, roomId) => {
if (meta.config.disableChat || uid <= 0) { if (meta.config.disableChat || uid <= 0) {
return callback(new Error('[[error:chat-disabled]]')); throw new Error('[[error:chat-disabled]]');
} }
async.waterfall([ const inRoom = await Messaging.isUserInRoom(uid, roomId);
function (next) {
Messaging.isUserInRoom(uid, roomId, next);
},
function (inRoom, next) {
if (!inRoom) { if (!inRoom) {
return next(new Error('[[error:not-in-room]]')); throw new Error('[[error:not-in-room]]');
} }
user.getUserFields(uid, ['banned', 'email:confirmed'], next); const userData = await user.getUserFields(uid, ['banned', 'email:confirmed']);
},
function (userData, next) {
if (userData.banned) { if (userData.banned) {
return next(new Error('[[error:user-banned]]')); throw new Error('[[error:user-banned]]');
} }
if (meta.config.requireEmailConfirmation && !userData['email:confirmed']) { if (meta.config.requireEmailConfirmation && !userData['email:confirmed']) {
return next(new Error('[[error:email-not-confirmed-chat]]')); throw new Error('[[error:email-not-confirmed-chat]]');
} }
plugins.fireHook('static:messaging.canMessageRoom', { await plugins.fireHook('static:messaging.canMessageRoom', {
uid: uid, uid: uid,
roomId: roomId, roomId: roomId,
}, function (err) {
next(err);
}); });
},
], callback);
}; };
Messaging.hasPrivateChat = function (uid, withUid, callback) { Messaging.hasPrivateChat = async (uid, withUid) => {
if (parseInt(uid, 10) === parseInt(withUid, 10)) { if (parseInt(uid, 10) === parseInt(withUid, 10)) {
return callback(null, 0); return 0;
} }
async.waterfall([
function (next) { const results = await utils.promiseParallel({
async.parallel({ myRooms: db.getSortedSetRevRange('uid:' + uid + ':chat:rooms', 0, -1),
myRooms: async.apply(db.getSortedSetRevRange, 'uid:' + uid + ':chat:rooms', 0, -1), theirRooms: db.getSortedSetRevRange('uid:' + withUid + ':chat:rooms', 0, -1),
theirRooms: async.apply(db.getSortedSetRevRange, 'uid:' + withUid + ':chat:rooms', 0, -1), });
}, next); const roomIds = results.myRooms.filter(function (roomId) {
},
function (results, next) {
var roomIds = results.myRooms.filter(function (roomId) {
return roomId && results.theirRooms.includes(roomId); return roomId && results.theirRooms.includes(roomId);
}); });
if (!roomIds.length) { if (!roomIds.length) {
return callback(); return 0;
} }
var index = 0; var index = 0;
var roomId = 0; var roomId = 0;
async.whilst(function (next) { while (index < roomIds.length && !roomId) {
next(null, index < roomIds.length && !roomId); /* eslint-disable no-await-in-loop */
}, function (next) { const count = await Messaging.getUserCountInRoom(roomIds[index]);
Messaging.getUserCountInRoom(roomIds[index], function (err, count) {
if (err) {
return next(err);
}
if (count === 2) { if (count === 2) {
roomId = roomIds[index]; roomId = roomIds[index];
next(null, roomId);
} else { } else {
index += 1; index += 1;
next();
} }
}); }
}, function (err) {
next(err, roomId); return roomId;
});
},
], callback);
}; };
Messaging.async = require('../promisify')(Messaging); Messaging.async = require('../promisify')(Messaging);

49
src/messaging/notifications.js
Unescape Escape View File

@ -1,7 +1,5 @@
'use strict'; 'use strict';
var async = require('async');
var user = require('../user'); var user = require('../user');
var notifications = require('../notifications'); var notifications = require('../notifications');
var sockets = require('../socket.io'); var sockets = require('../socket.io');
@ -12,31 +10,22 @@ module.exports = function (Messaging) {
Messaging.notificationSendDelay = 1000 * 60; Messaging.notificationSendDelay = 1000 * 60;
Messaging.notifyUsersInRoom = function (fromUid, roomId, messageObj) { Messaging.notifyUsersInRoom = async (fromUid, roomId, messageObj) => {
async.waterfall([ let uids = await Messaging.getUidsInRoom(roomId, 0, -1);
function (next) { uids = await user.blocks.filterUids(fromUid, uids);
Messaging.getUidsInRoom(roomId, 0, -1, next);
}, let data = {
function (uids, next) {
user.blocks.filterUids(fromUid, uids, next);
},
function (uids, next) {
var data = {
roomId: roomId, roomId: roomId,
fromUid: fromUid, fromUid: fromUid,
message: messageObj, message: messageObj,
uids: uids, uids: uids,
}; };
data = await plugins.fireHook('filter:messaging.notify', data);
plugins.fireHook('filter:messaging.notify', data, next);
},
function (data, next) {
if (!data || !data.uids || !data.uids.length) { if (!data || !data.uids || !data.uids.length) {
return next(); return;
} }
var uids = data.uids; uids = data.uids;
uids.forEach(function (uid) { uids.forEach(function (uid) {
data.self = parseInt(uid, 10) === parseInt(fromUid, 10) ? 1 : 0; data.self = parseInt(uid, 10) === parseInt(fromUid, 10) ? 1 : 0;
Messaging.pushUnreadCount(uid); Messaging.pushUnreadCount(uid);
@ -58,26 +47,18 @@ module.exports = function (Messaging) {
queueObj.timeout = setTimeout(function () { queueObj.timeout = setTimeout(function () {
sendNotifications(fromUid, uids, roomId, queueObj.message); sendNotifications(fromUid, uids, roomId, queueObj.message);
}, Messaging.notificationSendDelay); }, Messaging.notificationSendDelay);
next();
},
]);
}; };
function sendNotifications(fromuid, uids, roomId, messageObj) { async function sendNotifications(fromuid, uids, roomId, messageObj) {
async.waterfall([ const isOnline = await user.isOnline(uids);
function (next) {
user.isOnline(uids, next);
},
function (isOnline, next) {
uids = uids.filter(function (uid, index) { uids = uids.filter(function (uid, index) {
return !isOnline[index] && parseInt(fromuid, 10) !== parseInt(uid, 10); return !isOnline[index] && parseInt(fromuid, 10) !== parseInt(uid, 10);
}); });
if (!uids.length) { if (!uids.length) {
return; return;
} }
notifications.create({ const notification = await notifications.create({
type: 'new-chat', type: 'new-chat',
subject: '[[email:notif.chat.subject, ' + messageObj.fromUser.username + ']]', subject: '[[email:notif.chat.subject, ' + messageObj.fromUser.username + ']]',
bodyShort: '[[notifications:new_message_from, ' + messageObj.fromUser.username + ']]', bodyShort: '[[notifications:new_message_from, ' + messageObj.fromUser.username + ']]',
@ -85,15 +66,11 @@ module.exports = function (Messaging) {
nid: 'chat_' + fromuid + '_' + roomId, nid: 'chat_' + fromuid + '_' + roomId,
from: fromuid, from: fromuid,
path: '/chats/' + messageObj.roomId, path: '/chats/' + messageObj.roomId,
}, next); });
},
], function (err, notification) {
if (!err) {
delete Messaging.notifyQueue[fromuid + ':' + roomId]; delete Messaging.notifyQueue[fromuid + ':' + roomId];
if (notification) { if (notification) {
notifications.push(notification, uids); notifications.push(notification, uids);
} }
} }
});
}
}; };

40
src/messaging/unread.js
Unescape Escape View File

@ -1,53 +1,37 @@
'use strict'; 'use strict';
var async = require('async');
var db = require('../database'); var db = require('../database');
var sockets = require('../socket.io'); var sockets = require('../socket.io');
module.exports = function (Messaging) { module.exports = function (Messaging) {
Messaging.getUnreadCount = function (uid, callback) { Messaging.getUnreadCount = async (uid) => {
if (parseInt(uid, 10) <= 0) { if (parseInt(uid, 10) <= 0) {
return setImmediate(callback, null, 0); return 0;
} }
db.sortedSetCard('uid:' + uid + ':chat:rooms:unread', callback);
return await db.sortedSetCard('uid:' + uid + ':chat:rooms:unread');
}; };
Messaging.pushUnreadCount = function (uid) { Messaging.pushUnreadCount = async (uid) => {
if (parseInt(uid, 10) <= 0) { if (parseInt(uid, 10) <= 0) {
return; return;
} }
Messaging.getUnreadCount(uid, function (err, unreadCount) { const unreadCount = await Messaging.getUnreadCount(uid);
if (err) {
return;
}
sockets.in('uid_' + uid).emit('event:unread.updateChatCount', unreadCount); sockets.in('uid_' + uid).emit('event:unread.updateChatCount', unreadCount);
});
};
Messaging.markRead = function (uid, roomId, callback) {
db.sortedSetRemove('uid:' + uid + ':chat:rooms:unread', roomId, callback);
}; };
Messaging.markAllRead = function (uid, callback) { Messaging.markRead = async (uid, roomId) => db.sortedSetRemove('uid:' + uid + ':chat:rooms:unread', roomId);
db.delete('uid:' + uid + ':chat:rooms:unread', callback); Messaging.markAllRead = async uid => db.delete('uid:' + uid + ':chat:rooms:unread');
};
Messaging.markUnread = function (uids, roomId, callback) { Messaging.markUnread = async (uids, roomId) => {
async.waterfall([ const exists = await Messaging.roomExists(roomId);
function (next) {
Messaging.roomExists(roomId, next);
},
function (exists, next) {
if (!exists) { if (!exists) {
return next(new Error('[[error:chat-room-does-not-exist]]')); throw new Error('[[error:chat-room-does-not-exist]]');
} }
var keys = uids.map(function (uid) { var keys = uids.map(function (uid) {
return 'uid:' + uid + ':chat:rooms:unread'; return 'uid:' + uid + ':chat:rooms:unread';
}); });
db.sortedSetsAdd(keys, Date.now(), roomId, next); return await db.sortedSetsAdd(keys, Date.now(), roomId);
},
], callback);
}; };
}; };

4
src/socket.io/modules.js
Unescape Escape View File

@ -278,7 +278,7 @@ SocketModules.chats.delete = function (socket, data, callback) {
Messaging.canDelete(data.messageId, socket.uid, next); Messaging.canDelete(data.messageId, socket.uid, next);
}, },
function (next) { function (next) {
Messaging.deleteMessage(data.messageId, data.roomId, next); Messaging.deleteMessage(data.messageId, next);
}, },
], callback); ], callback);
}; };
@ -293,7 +293,7 @@ SocketModules.chats.restore = function (socket, data, callback) {
Messaging.canDelete(data.messageId, socket.uid, next); Messaging.canDelete(data.messageId, socket.uid, next);
}, },
function (next) { function (next) {
Messaging.restoreMessage(data.messageId, data.roomId, next); Messaging.restoreMessage(data.messageId, next);
}, },
], callback); ], callback);
}; };

Write Preview
Loading…
Cancel
Save