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

refactor: globalmods/groups

Browse Source
v1.18.x
Baris Usakli 6 years ago
parent bd8736db38
commit 0722cc4715
2 changed files with 133 additions and 198 deletions
Show Stats Download Patch File Download Diff File

46
src/controllers/globalmods.js
Unescape Escape 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) { if (!isAdminOrGlobalMod) {
async.waterfall([ return next();
function (next) { }
user.isAdminOrGlobalMod(req.uid, next); await adminBlacklistController.get(req, res);
},
function (isAdminOrGlobalMod, next) {
if (!isAdminOrGlobalMod) {
return next();
}
adminBlacklistController.get(req, res, next);
},
], 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) { if (!isAdminOrGlobalMod) {
user.isAdminOrGlobalMod(req.uid, next); return next();
}, }
function (isAdminOrGlobalMod, next) { await usersController.registrationQueue(req, res);
if (!isAdminOrGlobalMod) {
return next();
}
usersController.registrationQueue(req, res, next);
},
], next);
}; };

285
src/controllers/groups.js
Unescape Escape 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) { data.title = '[[pages:groups]]';
return next(err); data.breadcrumbs = helpers.buildBreadcrumbs([{ text: '[[pages:groups]]' }]);
} res.render('groups/list', data);
data.title = '[[pages:groups]]';
data.breadcrumbs = helpers.buildBreadcrumbs([{ text: '[[pages:groups]]' }]);
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,
}, nextStart: stop + 1,
function (results, next) { };
next(null, {
groups: results.groupsData,
allowGroupCreation: results.allowGroupCreation,
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([ if (!groupName) {
function (next) { return next();
groups.getGroupNameByGroupSlug(req.params.slug, next); }
}, const [exists, isHidden] = await Promise.all([
function (_groupName, next) { groups.exists(groupName),
groupName = _groupName; groups.isHidden(groupName),
if (!groupName) { ]);
return callback(); if (!exists) {
} return next();
async.parallel({ }
exists: async.apply(groups.exists, groupName), if (isHidden) {
hidden: async.apply(groups.isHidden, groupName), const [isMember, isInvited] = await Promise.all([
}, next); groups.isMember(req.uid, groupName),
}, groups.isInvited(req.uid, groupName),
function (results, next) { ]);
if (!results.exists) { if (!isMember && !isInvited) {
return callback(); return next();
} }
if (!results.hidden) { }
return next(); const [groupData, posts, isAdmin, isGlobalMod] = await Promise.all([
} groups.get(groupName, {
async.parallel({ uid: req.uid,
isMember: async.apply(groups.isMember, req.uid, groupName), truncateUserList: true,
isInvited: async.apply(groups.isInvited, req.uid, groupName), userListCount: 20,
}, function (err, checks) { }),
if (err || checks.isMember || checks.isInvited) { groups.getLatestMemberPosts(groupName, 10, req.uid),
return next(err); user.isAdministrator(req.uid),
} user.isGlobalModerator(req.uid),
callback(); ]);
}); if (!groupData) {
}, return next();
function (next) { }
async.parallel({ groupData.isOwner = groupData.isOwner || isAdmin || (isGlobalMod && !groupData.system);
group: function (next) { const results = {
groups.get(groupName, { title: '[[pages:group, ' + groupData.displayName + ']]',
uid: req.uid, group: groupData,
truncateUserList: true, posts: posts,
userListCount: 20, isAdmin: isAdmin,
}, next); isGlobalMod: isGlobalMod,
}, allowPrivateGroups: meta.config.allowPrivateGroups,
posts: function (next) { breadcrumbs: helpers.buildBreadcrumbs([{ text: '[[pages:groups]]', url: '/groups' }, { text: groupData.displayName }]),
groups.getLatestMemberPosts(groupName, 10, req.uid, next); };
},
isAdmin: function (next) { res.render('groups/details', results);
user.isAdministrator(req.uid, 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);
results.title = '[[pages:group, ' + results.group.displayName + ']]';
results.breadcrumbs = helpers.buildBreadcrumbs([{ text: '[[pages:groups]]', url: '/groups' }, { text: results.group.displayName }]);
results.allowPrivateGroups = meta.config.allowPrivateGroups;
res.render('groups/details', results);
},
], callback);
}; };
groupsController.members = function (req, res, callback) { groupsController.members = async function (req, res, next) {
var page = parseInt(req.query.page, 10) || 1; const page = parseInt(req.query.page, 10) || 1;
var usersPerPage = 50; const usersPerPage = 50;
var start = Math.max(0, (page - 1) * usersPerPage); const start = Math.max(0, (page - 1) * usersPerPage);
var stop = start + usersPerPage - 1; const stop = start + usersPerPage - 1;
var groupName; const groupName = await groups.getGroupNameByGroupSlug(req.params.slug);
var groupData; if (!groupName) {
async.waterfall([ return next();
function (next) { }
groups.getGroupNameByGroupSlug(req.params.slug, next); const [groupData, isAdminOrGlobalMod, isMember, isHidden] = await Promise.all([
}, groups.getGroupData(groupName),
function (_groupName, next) { user.isAdminOrGlobalMod(req.uid),
if (!_groupName) { groups.isMember(req.uid, groupName),
return callback(); groups.isHidden(groupName),
} ]);
groupName = _groupName;
async.parallel({ if (isHidden && !isMember && !isAdminOrGlobalMod) {
isAdminOrGlobalMod: async.apply(user.isAdminOrGlobalMod, req.uid), return next();
isMember: async.apply(groups.isMember, req.uid, groupName), }
isHidden: async.apply(groups.isHidden, groupName), const users = await user.getUsersFromSet('group:' + groupName + ':members', req.uid, start, stop);
groupData: async.apply(groups.getGroupData, groupName),
}, next); const breadcrumbs = helpers.buildBreadcrumbs([
}, { text: '[[pages:groups]]', url: '/groups' },
function (results, next) { { text: validator.escape(String(groupName)), url: '/groups/' + req.params.slug },
if (results.isHidden && !results.isMember && !results.isAdminOrGlobalMod) { { text: '[[groups:details.members]]' },
return callback(); ]);
}
groupData = results.groupData; const pageCount = Math.max(1, Math.ceil(groupData.memberCount / usersPerPage));
res.render('groups/members', {
user.getUsersFromSet('group:' + groupName + ':members', req.uid, start, stop, next); users: users,
}, pagination: pagination.create(page, pageCount, req.query),
function (users) { breadcrumbs: breadcrumbs,
var breadcrumbs = helpers.buildBreadcrumbs([ });
{ text: '[[pages:groups]]', url: '/groups' },
{ text: validator.escape(String(groupName)), url: '/groups/' + req.params.slug },
{ text: '[[groups:details.members]]' },
]);
var pageCount = Math.max(1, Math.ceil(groupData.memberCount / usersPerPage));
res.render('groups/members', {
users: users,
pagination: pagination.create(page, pageCount, req.query),
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); if (!isOwner) {
}, throw new Error('[[error:no-privileges]]');
function (isOwner, next) {
if (!isOwner) {
return next(new Error('[[error:no-privileges]]'));
}
groups.updateCover(req.uid, {
file: req.files.files[0].path,
groupName: params.groupName,
}, next);
},
], function (err, image) {
if (err) {
return next(err);
} }
const image = await groups.updateCover(req.uid, {
file: req.files.files[0].path,
groupName: params.groupName,
});
res.json([{ url: image.url }]); res.json([{ url: image.url }]);
}); } catch (err) {
next(err);
}
}; };
require('../promisify')(groupsController); require('../promisify')(groupsController, ['list', 'details', 'members', 'uploadCover']);

Write Preview
Loading…
Cancel
Save