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

* 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
This commit is contained in:
Julian Lam
2019-07-22 11:18:13 -04:00
committed by GitHub
parent fcf8fd51cb
commit 756a717eb8
8 changed files with 541 additions and 813 deletions

View File

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