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

refactor: async/await

Browse Source
v1.18.x
Barış Soner Uşaklı 6 years ago
parent 2f02edbc3c
commit f15c7f12b3
5 changed files with 124 additions and 177 deletions
Show Stats Download Patch File Download Diff File

39
src/controllers/groups.js
Unescape Escape View File

@ -14,28 +14,18 @@ const groupsController = module.exports;
groupsController.list = async function (req, res) { groupsController.list = async function (req, res) {
const sort = req.query.sort || 'alpha'; const sort = req.query.sort || 'alpha';
const data = await groupsController.getGroupsFromSet(req.uid, sort, 0, 14); const [groupData, allowGroupCreation] = await Promise.all([
data.title = '[[pages:groups]]'; groups.getGroupsBySort(sort, 0, 14),
data.breadcrumbs = helpers.buildBreadcrumbs([{ text: '[[pages:groups]]' }]); privileges.global.can('group:create', req.uid),
res.render('groups/list', data);
};
groupsController.getGroupsFromSet = async function (uid, sort, start, stop) {
let set = 'groups:visible:name';
if (sort === 'count') {
set = 'groups:visible:memberCount';
} else if (sort === 'date') {
set = 'groups:visible:createtime';
}
const [groupsData, allowGroupCreation] = await Promise.all([
groups.getGroupsFromSet(set, uid, start, stop),
privileges.global.can('group:create', uid),
]); ]);
return {
groups: groupsData, res.render('groups/list', {
groups: groupData,
allowGroupCreation: allowGroupCreation, allowGroupCreation: allowGroupCreation,
nextStart: stop + 1, nextStart: 15,
}; title: '[[pages:groups]]',
breadcrumbs: helpers.buildBreadcrumbs([{ text: '[[pages:groups]]' }]),
});
}; };
groupsController.details = async function (req, res, next) { groupsController.details = async function (req, res, next) {
@ -73,7 +63,8 @@ groupsController.details = async function (req, res, next) {
return next(); return next();
} }
groupData.isOwner = groupData.isOwner || isAdmin || (isGlobalMod && !groupData.system); groupData.isOwner = groupData.isOwner || isAdmin || (isGlobalMod && !groupData.system);
const results = {
res.render('groups/details', {
title: '[[pages:group, ' + groupData.displayName + ']]', title: '[[pages:group, ' + groupData.displayName + ']]',
group: groupData, group: groupData,
posts: posts, posts: posts,
@ -81,9 +72,7 @@ groupsController.details = async function (req, res, next) {
isGlobalMod: isGlobalMod, isGlobalMod: isGlobalMod,
allowPrivateGroups: meta.config.allowPrivateGroups, allowPrivateGroups: meta.config.allowPrivateGroups,
breadcrumbs: helpers.buildBreadcrumbs([{ text: '[[pages:groups]]', url: '/groups' }, { text: groupData.displayName }]), breadcrumbs: helpers.buildBreadcrumbs([{ text: '[[pages:groups]]', url: '/groups' }, { text: groupData.displayName }]),
}; });
res.render('groups/details', results);
}; };
groupsController.members = async function (req, res, next) { groupsController.members = async function (req, res, next) {
@ -138,5 +127,3 @@ groupsController.uploadCover = async function (req, res, next) {
next(err); next(err);
} }
}; };
require('../promisify')(groupsController, ['list', 'details', 'members', 'uploadCover']);

148
src/controllers/helpers.js
Unescape Escape View File

@ -1,28 +1,27 @@
'use strict'; 'use strict';
var nconf = require('nconf'); const nconf = require('nconf');
var async = require('async'); const validator = require('validator');
var validator = require('validator'); const winston = require('winston');
var winston = require('winston'); const querystring = require('querystring');
var querystring = require('querystring');
const user = require('../user');
var user = require('../user'); const privileges = require('../privileges');
var privileges = require('../privileges'); const categories = require('../categories');
var categories = require('../categories'); const plugins = require('../plugins');
var plugins = require('../plugins'); const meta = require('../meta');
var meta = require('../meta'); const middleware = require('../middleware');
var middleware = require('../middleware'); const utils = require('../utils');
var utils = require('../utils');
const helpers = module.exports;
var helpers = module.exports;
helpers.noScriptErrors = function (req, res, error, httpStatus) { helpers.noScriptErrors = function (req, res, error, httpStatus) {
if (req.body.noscript !== 'true') { if (req.body.noscript !== 'true') {
return res.status(httpStatus).send(error); return res.status(httpStatus).send(error);
} }
var middleware = require('../middleware'); const middleware = require('../middleware');
var httpStatusString = httpStatus.toString(); const httpStatusString = httpStatus.toString();
middleware.buildHeader(req, res, function () { middleware.buildHeader(req, res, function () {
res.status(httpStatus).render(httpStatusString, { res.status(httpStatus).render(httpStatusString, {
path: req.path, path: req.path,
@ -43,7 +42,7 @@ helpers.terms = {
}; };
helpers.buildQueryString = function (cid, filter, term) { helpers.buildQueryString = function (cid, filter, term) {
var qs = {}; const qs = {};
if (cid) { if (cid) {
qs.cid = cid; qs.cid = cid;
} }
@ -54,10 +53,7 @@ helpers.buildQueryString = function (cid, filter, term) {
qs.term = term; qs.term = term;
} }
if (Object.keys(qs).length) { return Object.keys(qs).length ? '?' + querystring.stringify(qs) : '';
return '?' + querystring.stringify(qs);
}
return '';
}; };
helpers.buildFilters = function (url, filter, query) { helpers.buildFilters = function (url, filter, query) {
@ -153,32 +149,20 @@ helpers.redirect = function (res, url) {
} }
}; };
helpers.buildCategoryBreadcrumbs = function (cid, callback) { helpers.buildCategoryBreadcrumbs = async function (cid) {
var breadcrumbs = []; const breadcrumbs = [];
async.whilst(function (next) {
next(null, parseInt(cid, 10));
}, function (next) {
categories.getCategoryFields(cid, ['name', 'slug', 'parentCid', 'disabled', 'isSection'], function (err, data) {
if (err) {
return next(err);
}
while (parseInt(cid, 10)) {
/* eslint-disable no-await-in-loop */
const data = await categories.getCategoryFields(cid, ['name', 'slug', 'parentCid', 'disabled', 'isSection']);
if (!data.disabled && !data.isSection) { if (!data.disabled && !data.isSection) {
breadcrumbs.unshift({ breadcrumbs.unshift({
text: String(data.name), text: String(data.name),
url: nconf.get('relative_path') + '/category/' + data.slug, url: nconf.get('relative_path') + '/category/' + data.slug,
}); });
} }
cid = data.parentCid; cid = data.parentCid;
next();
});
}, function (err) {
if (err) {
return callback(err);
} }
if (meta.config.homePageRoute && meta.config.homePageRoute !== 'categories') { if (meta.config.homePageRoute && meta.config.homePageRoute !== 'categories') {
breadcrumbs.unshift({ breadcrumbs.unshift({
text: '[[global:header.categories]]', text: '[[global:header.categories]]',
@ -191,12 +175,11 @@ helpers.buildCategoryBreadcrumbs = function (cid, callback) {
url: nconf.get('relative_path') + '/', url: nconf.get('relative_path') + '/',
}); });
callback(null, breadcrumbs); return breadcrumbs;
});
}; };
helpers.buildBreadcrumbs = function (crumbs) { helpers.buildBreadcrumbs = function (crumbs) {
var breadcrumbs = [ const breadcrumbs = [
{ {
text: '[[global:home]]', text: '[[global:home]]',
url: nconf.get('relative_path') + '/', url: nconf.get('relative_path') + '/',
@ -216,69 +199,40 @@ helpers.buildBreadcrumbs = function (crumbs) {
}; };
helpers.buildTitle = function (pageTitle) { helpers.buildTitle = function (pageTitle) {
var titleLayout = meta.config.titleLayout || '{pageTitle} | {browserTitle}'; const titleLayout = meta.config.titleLayout || '{pageTitle} | {browserTitle}';
var browserTitle = validator.escape(String(meta.config.browserTitle || meta.config.title || 'NodeBB')); const browserTitle = validator.escape(String(meta.config.browserTitle || meta.config.title || 'NodeBB'));
pageTitle = pageTitle || ''; pageTitle = pageTitle || '';
var title = titleLayout.replace('{pageTitle}', function () { const title = titleLayout.replace('{pageTitle}', () => pageTitle).replace('{browserTitle}', () => browserTitle);
return pageTitle;
}).replace('{browserTitle}', function () {
return browserTitle;
});
return title; return title;
}; };
helpers.getCategories = function (set, uid, privilege, selectedCid, callback) { helpers.getCategories = async function (set, uid, privilege, selectedCid) {
async.waterfall([ const cids = await categories.getCidsByPrivilege(set, uid, privilege);
function (next) { return await getCategoryData(cids, uid, selectedCid);
categories.getCidsByPrivilege(set, uid, privilege, next);
},
function (cids, next) {
getCategoryData(cids, uid, selectedCid, next);
},
], callback);
}; };
helpers.getCategoriesByStates = function (uid, selectedCid, states, callback) { helpers.getCategoriesByStates = async function (uid, selectedCid, states) {
async.waterfall([ let cids = await user.getCategoriesByStates(uid, states);
function (next) { cids = await privileges.categories.filterCids('read', cids, uid);
user.getCategoriesByStates(uid, states, next); return await getCategoryData(cids, uid, selectedCid);
},
function (cids, next) {
privileges.categories.filterCids('read', cids, uid, next);
},
function (cids, next) {
getCategoryData(cids, uid, selectedCid, next);
},
], callback);
}; };
helpers.getWatchedCategories = function (uid, selectedCid, callback) { helpers.getWatchedCategories = async function (uid, selectedCid) {
async.waterfall([ let cids = await user.getWatchedCategories(uid);
function (next) { cids = await privileges.categories.filterCids('read', cids, uid);
user.getWatchedCategories(uid, next); return await getCategoryData(cids, uid, selectedCid);
},
function (cids, next) {
privileges.categories.filterCids('read', cids, uid, next);
},
function (cids, next) {
getCategoryData(cids, uid, selectedCid, next);
},
], callback);
}; };
function getCategoryData(cids, uid, selectedCid, callback) { async function getCategoryData(cids, uid, selectedCid) {
if (selectedCid && !Array.isArray(selectedCid)) { if (selectedCid && !Array.isArray(selectedCid)) {
selectedCid = [selectedCid]; selectedCid = [selectedCid];
} }
async.waterfall([ let categoryData = await categories.getCategoriesFields(cids, ['cid', 'order', 'name', 'slug', 'icon', 'link', 'color', 'bgColor', 'parentCid', 'image', 'imageClass']);
function (next) {
categories.getCategoriesFields(cids, ['cid', 'order', 'name', 'slug', 'icon', 'link', 'color', 'bgColor', 'parentCid', 'image', 'imageClass'], next);
},
function (categoryData, next) {
categoryData = categoryData.filter(category => category && !category.link); categoryData = categoryData.filter(category => category && !category.link);
var selectedCategory = [];
var selectedCids = []; let selectedCategory = [];
const selectedCids = [];
categoryData.forEach(function (category) { categoryData.forEach(function (category) {
category.selected = selectedCid ? selectedCid.includes(String(category.cid)) : false; category.selected = selectedCid ? selectedCid.includes(String(category.cid)) : false;
category.parentCid = category.hasOwnProperty('parentCid') && utils.isNumber(category.parentCid) ? category.parentCid : 0; category.parentCid = category.hasOwnProperty('parentCid') && utils.isNumber(category.parentCid) ? category.parentCid : 0;
@ -301,16 +255,12 @@ function getCategoryData(cids, uid, selectedCid, callback) {
selectedCategory = undefined; selectedCategory = undefined;
} }
var categoriesData = []; const categoriesData = [];
var tree = categories.getTree(categoryData); const tree = categories.getTree(categoryData);
tree.forEach(function (category) { tree.forEach(category => recursive(category, categoriesData, ''));
recursive(category, categoriesData, '');
});
next(null, { categories: categoriesData, selectedCategory: selectedCategory, selectedCids: selectedCids }); return { categories: categoriesData, selectedCategory: selectedCategory, selectedCids: selectedCids };
},
], callback);
} }
function recursive(category, categoriesData, level) { function recursive(category, categoriesData, level) {
@ -365,4 +315,4 @@ helpers.getHomePageRoutes = async function (uid) {
return data.routes; return data.routes;
}; };
helpers.async = require('../promisify')(helpers); require('../promisify')(helpers);

12
src/groups/index.js
Unescape Escape View File

@ -51,7 +51,7 @@ Groups.isPrivilegeGroup = function (groupName) {
return isPrivilegeGroupRegex.test(groupName); return isPrivilegeGroupRegex.test(groupName);
}; };
Groups.getGroupsFromSet = async function (set, uid, start, stop) { Groups.getGroupsFromSet = async function (set, start, stop) {
let groupNames; let groupNames;
if (set === 'groups:visible:name') { if (set === 'groups:visible:name') {
groupNames = await db.getSortedSetRangeByLex(set, '-', '+', start, stop - start + 1); groupNames = await db.getSortedSetRangeByLex(set, '-', '+', start, stop - start + 1);
@ -65,6 +65,16 @@ Groups.getGroupsFromSet = async function (set, uid, start, stop) {
return await Groups.getGroupsAndMembers(groupNames); return await Groups.getGroupsAndMembers(groupNames);
}; };
Groups.getGroupsBySort = async function (sort, start, stop) {
let set = 'groups:visible:name';
if (sort === 'count') {
set = 'groups:visible:memberCount';
} else if (sort === 'date') {
set = 'groups:visible:createtime';
}
return await Groups.getGroupsFromSet(set, start, stop);
};
Groups.getNonPrivilegeGroups = async function (set, start, stop) { Groups.getNonPrivilegeGroups = async function (set, start, stop) {
let groupNames = await db.getSortedSetRevRange(set, start, stop); let groupNames = await db.getSortedSetRevRange(set, start, stop);
groupNames = groupNames.concat(Groups.ephemeralGroups).filter(groupName => !Groups.isPrivilegeGroup(groupName)); groupNames = groupNames.concat(Groups.ephemeralGroups).filter(groupName => !Groups.isPrivilegeGroup(groupName));

30
src/socket.io/groups.js
Unescape Escape View File

@ -1,14 +1,13 @@
'use strict'; 'use strict';
var groups = require('../groups'); const groups = require('../groups');
var meta = require('../meta'); const meta = require('../meta');
var user = require('../user'); const user = require('../user');
var utils = require('../utils'); const utils = require('../utils');
var groupsController = require('../controllers/groups'); const events = require('../events');
var events = require('../events'); const privileges = require('../privileges');
var privileges = require('../privileges');
var SocketGroups = module.exports; const SocketGroups = module.exports;
SocketGroups.before = async (socket, method, data) => { SocketGroups.before = async (socket, method, data) => {
if (!data) { if (!data) {
@ -271,9 +270,9 @@ SocketGroups.search = async (socket, data) => {
data.options = data.options || {}; data.options = data.options || {};
if (!data.query) { if (!data.query) {
var groupsPerPage = 15; const groupsPerPage = 15;
const groups = await groupsController.getGroupsFromSet(socket.uid, data.options.sort, 0, groupsPerPage - 1); const groupData = await groups.getGroupsBySort(data.options.sort, 0, groupsPerPage - 1);
return groups.groups; return groupData;
} }
return await groups.search(data.query, data.options); return await groups.search(data.query, data.options);
@ -284,10 +283,11 @@ SocketGroups.loadMore = async (socket, data) => {
throw new Error('[[error:invalid-data]]'); throw new Error('[[error:invalid-data]]');
} }
var groupsPerPage = 9; const groupsPerPage = 10;
var start = parseInt(data.after, 10); const start = parseInt(data.after, 10);
var stop = start + groupsPerPage - 1; const stop = start + groupsPerPage - 1;
return await groupsController.getGroupsFromSet(socket.uid, data.sort, start, stop); const groupData = await groups.getGroupsBySort(data.sort, start, stop);
return { groups: groupData, nextStart: stop + 1 };
}; };
SocketGroups.searchMembers = async (socket, data) => { SocketGroups.searchMembers = async (socket, data) => {

2
test/groups.js
Unescape Escape View File

@ -70,7 +70,7 @@ describe('Groups', function () {
describe('.list()', function () { describe('.list()', function () {
it('should list the groups present', function (done) { it('should list the groups present', function (done) {
Groups.getGroupsFromSet('groups:visible:createtime', 0, 0, -1, function (err, groups) { Groups.getGroupsFromSet('groups:visible:createtime', 0, -1, function (err, groups) {
assert.ifError(err); assert.ifError(err);
assert.equal(groups.length, 4); assert.equal(groups.length, 4);
done(); done();

Write Preview
Loading…
Cancel
Save