Nemcio/NodeBB
1
0
Fork 0
mirror of https://github.com/NodeBB/NodeBB.git synced 2025-10-31 11:05:54 +01:00
Code Issues Packages Projects Releases Wiki Activity

refactor: globalmods/groups

Browse Source
This commit is contained in:
Baris Usakli
2019-08-19 17:18:33 -04:00
parent bd8736db38
commit 0722cc4715
2 changed files with 139 additions and 204 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
src/controllers/globalmods.js
View File

@@ -1,38 +1,24 @@
'use strict'; 'use strict';
var async = require('async'); const user = require('../user');
const adminBlacklistController = require('./admin/blacklist');
const usersController = require('./admin/users');
var user = require('../user'); const globalModsController = module.exports;
var adminBlacklistController = require('./admin/blacklist');
var usersController = require('./admin/users');
var globalModsController = module.exports; globalModsController.ipBlacklist = async function (req, res, next) {
const isAdminOrGlobalMod = await user.isAdminOrGlobalMod(req.uid);
globalModsController.ipBlacklist = function (req, res, next) {
async.waterfall([
function (next) {
user.isAdminOrGlobalMod(req.uid, next);
},
function (isAdminOrGlobalMod, next) {
if (!isAdminOrGlobalMod) { if (!isAdminOrGlobalMod) {
return next(); return next();
} }
adminBlacklistController.get(req, res, next); await adminBlacklistController.get(req, res);
},
], next);
}; };
globalModsController.registrationQueue = function (req, res, next) { globalModsController.registrationQueue = async function (req, res, next) {
async.waterfall([ const isAdminOrGlobalMod = await user.isAdminOrGlobalMod(req.uid);
function (next) {
user.isAdminOrGlobalMod(req.uid, next);
},
function (isAdminOrGlobalMod, next) {
if (!isAdminOrGlobalMod) { if (!isAdminOrGlobalMod) {
return next(); return next();
} }
usersController.registrationQueue(req, res, next); await usersController.registrationQueue(req, res);
},
], next);
}; };

231
src/controllers/groups.js
View File

@@ -1,193 +1,142 @@
'use strict'; 'use strict';
var async = require('async'); const validator = require('validator');
var validator = require('validator');
var meta = require('../meta'); const meta = require('../meta');
var groups = require('../groups'); const groups = require('../groups');
var user = require('../user'); const user = require('../user');
var helpers = require('./helpers'); const helpers = require('./helpers');
var pagination = require('../pagination'); const pagination = require('../pagination');
var privileges = require('../privileges'); const privileges = require('../privileges');
var groupsController = module.exports; const groupsController = module.exports;
groupsController.list = function (req, res, next) { groupsController.list = async function (req, res) {
var sort = req.query.sort || 'alpha'; const sort = req.query.sort || 'alpha';
groupsController.getGroupsFromSet(req.uid, sort, 0, 14, function (err, data) { const data = await groupsController.getGroupsFromSet(req.uid, sort, 0, 14);
if (err) {
return next(err);
}
data.title = '[[pages:groups]]'; data.title = '[[pages:groups]]';
data.breadcrumbs = helpers.buildBreadcrumbs([{ text: '[[pages:groups]]' }]); data.breadcrumbs = helpers.buildBreadcrumbs([{ text: '[[pages:groups]]' }]);
res.render('groups/list', data); res.render('groups/list', data);
});
}; };
groupsController.getGroupsFromSet = function (uid, sort, start, stop, callback) { groupsController.getGroupsFromSet = async function (uid, sort, start, stop) {
var set = 'groups:visible:name'; let set = 'groups:visible:name';
if (sort === 'count') { if (sort === 'count') {
set = 'groups:visible:memberCount'; set = 'groups:visible:memberCount';
} else if (sort === 'date') { } else if (sort === 'date') {
set = 'groups:visible:createtime'; set = 'groups:visible:createtime';
} }
const [groupsData, allowGroupCreation] = await Promise.all([
async.waterfall([ groups.getGroupsFromSet(set, uid, start, stop),
function (next) { privileges.global.can('group:create', uid),
async.parallel({ ]);
groupsData: async.apply(groups.getGroupsFromSet, set, uid, start, stop), return {
allowGroupCreation: async.apply(privileges.global.can, 'group:create', uid), groups: groupsData,
}, next); allowGroupCreation: allowGroupCreation,
},
function (results, next) {
next(null, {
groups: results.groupsData,
allowGroupCreation: results.allowGroupCreation,
nextStart: stop + 1, nextStart: stop + 1,
}); };
},
], callback);
}; };
groupsController.details = function (req, res, callback) { groupsController.details = async function (req, res, next) {
var groupName; const groupName = await groups.getGroupNameByGroupSlug(req.params.slug);
async.waterfall([
function (next) {
groups.getGroupNameByGroupSlug(req.params.slug, next);
},
function (_groupName, next) {
groupName = _groupName;
if (!groupName) { if (!groupName) {
return callback();
}
async.parallel({
exists: async.apply(groups.exists, groupName),
hidden: async.apply(groups.isHidden, groupName),
}, next);
},
function (results, next) {
if (!results.exists) {
return callback();
}
if (!results.hidden) {
return next(); return next();
} }
async.parallel({ const [exists, isHidden] = await Promise.all([
isMember: async.apply(groups.isMember, req.uid, groupName), groups.exists(groupName),
isInvited: async.apply(groups.isInvited, req.uid, groupName), groups.isHidden(groupName),
}, function (err, checks) { ]);
if (err || checks.isMember || checks.isInvited) { if (!exists) {
return next(err); return next();
} }
callback(); if (isHidden) {
}); const [isMember, isInvited] = await Promise.all([
}, groups.isMember(req.uid, groupName),
function (next) { groups.isInvited(req.uid, groupName),
async.parallel({ ]);
group: function (next) { if (!isMember && !isInvited) {
return next();
}
}
const [groupData, posts, isAdmin, isGlobalMod] = await Promise.all([
groups.get(groupName, { groups.get(groupName, {
uid: req.uid, uid: req.uid,
truncateUserList: true, truncateUserList: true,
userListCount: 20, userListCount: 20,
}, next); }),
}, groups.getLatestMemberPosts(groupName, 10, req.uid),
posts: function (next) { user.isAdministrator(req.uid),
groups.getLatestMemberPosts(groupName, 10, req.uid, next); user.isGlobalModerator(req.uid),
}, ]);
isAdmin: function (next) { if (!groupData) {
user.isAdministrator(req.uid, next); return next();
},
isGlobalMod: function (next) {
user.isGlobalModerator(req.uid, next);
},
}, next);
},
function (results) {
if (!results.group) {
return callback();
} }
results.group.isOwner = results.group.isOwner || results.isAdmin || (results.isGlobalMod && !results.group.system); groupData.isOwner = groupData.isOwner || isAdmin || (isGlobalMod && !groupData.system);
results.title = '[[pages:group, ' + results.group.displayName + ']]'; const results = {
results.breadcrumbs = helpers.buildBreadcrumbs([{ text: '[[pages:groups]]', url: '/groups' }, { text: results.group.displayName }]); title: '[[pages:group, ' + groupData.displayName + ']]',
results.allowPrivateGroups = meta.config.allowPrivateGroups; group: groupData,
posts: posts,
res.render('groups/details', results); isAdmin: isAdmin,
}, isGlobalMod: isGlobalMod,
], callback); allowPrivateGroups: meta.config.allowPrivateGroups,
breadcrumbs: helpers.buildBreadcrumbs([{ text: '[[pages:groups]]', url: '/groups' }, { text: groupData.displayName }]),
}; };
groupsController.members = function (req, res, callback) { res.render('groups/details', results);
var page = parseInt(req.query.page, 10) || 1; };
var usersPerPage = 50;
var start = Math.max(0, (page - 1) * usersPerPage);
var stop = start + usersPerPage - 1;
var groupName;
var groupData;
async.waterfall([
function (next) {
groups.getGroupNameByGroupSlug(req.params.slug, next);
},
function (_groupName, next) {
if (!_groupName) {
return callback();
}
groupName = _groupName;
async.parallel({
isAdminOrGlobalMod: async.apply(user.isAdminOrGlobalMod, req.uid),
isMember: async.apply(groups.isMember, req.uid, groupName),
isHidden: async.apply(groups.isHidden, groupName),
groupData: async.apply(groups.getGroupData, groupName),
}, next);
},
function (results, next) {
if (results.isHidden && !results.isMember && !results.isAdminOrGlobalMod) {
return callback();
}
groupData = results.groupData;
user.getUsersFromSet('group:' + groupName + ':members', req.uid, start, stop, next); groupsController.members = async function (req, res, next) {
}, const page = parseInt(req.query.page, 10) || 1;
function (users) { const usersPerPage = 50;
var breadcrumbs = helpers.buildBreadcrumbs([ const start = Math.max(0, (page - 1) * usersPerPage);
const stop = start + usersPerPage - 1;
const groupName = await groups.getGroupNameByGroupSlug(req.params.slug);
if (!groupName) {
return next();
}
const [groupData, isAdminOrGlobalMod, isMember, isHidden] = await Promise.all([
groups.getGroupData(groupName),
user.isAdminOrGlobalMod(req.uid),
groups.isMember(req.uid, groupName),
groups.isHidden(groupName),
]);
if (isHidden && !isMember && !isAdminOrGlobalMod) {
return next();
}
const users = await user.getUsersFromSet('group:' + groupName + ':members', req.uid, start, stop);
const breadcrumbs = helpers.buildBreadcrumbs([
{ text: '[[pages:groups]]', url: '/groups' }, { text: '[[pages:groups]]', url: '/groups' },
{ text: validator.escape(String(groupName)), url: '/groups/' + req.params.slug }, { text: validator.escape(String(groupName)), url: '/groups/' + req.params.slug },
{ text: '[[groups:details.members]]' }, { text: '[[groups:details.members]]' },
]); ]);
var pageCount = Math.max(1, Math.ceil(groupData.memberCount / usersPerPage)); const pageCount = Math.max(1, Math.ceil(groupData.memberCount / usersPerPage));
res.render('groups/members', { res.render('groups/members', {
users: users, users: users,
pagination: pagination.create(page, pageCount, req.query), pagination: pagination.create(page, pageCount, req.query),
breadcrumbs: breadcrumbs, breadcrumbs: breadcrumbs,
}); });
},
], callback);
}; };
groupsController.uploadCover = function (req, res, next) { groupsController.uploadCover = async function (req, res, next) {
var params = JSON.parse(req.body.params); var params = JSON.parse(req.body.params);
async.waterfall([ try {
function (next) { const isOwner = await groups.ownership.isOwner(req.uid, params.groupName);
groups.ownership.isOwner(req.uid, params.groupName, next);
},
function (isOwner, next) {
if (!isOwner) { if (!isOwner) {
return next(new Error('[[error:no-privileges]]')); throw new Error('[[error:no-privileges]]');
} }
const image = await groups.updateCover(req.uid, {
groups.updateCover(req.uid, {
file: req.files.files[0].path, file: req.files.files[0].path,
groupName: params.groupName, groupName: params.groupName,
}, next);
},
], function (err, image) {
if (err) {
return next(err);
}
res.json([{ url: image.url }]);
}); });
res.json([{ url: image.url }]);
} catch (err) {
next(err);
}
}; };
require('../promisify')(groupsController); require('../promisify')(groupsController, ['list', 'details', 'members', 'uploadCover']);