10727519299

Committed 05 Sep 2024 08:15PM UTC coverage: 82.667% (-0.004%) from 82.671%

Build # 10727519299

Build Type

Pull #558

github

Committed by

web-flow

Commit Message

Merge b0e225799 into e7cfda55c

Pull Request Pull Request #558: Refactor code in src/middleware/admin.js to reduce cognitive complexity

Run Details

9962 of 13472 branches covered (73.95%)

Branch coverage included in aggregate %.

10 of 12 new or added lines in 1 file covered. (83.33%)

1 existing line in 1 file now uncovered.

22326 of 25586 relevant lines covered (87.26%)

1632.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

65.82

/src/middleware/admin.js

'use strict';


const nconf = require('nconf');

const user = require('../user');
const meta = require('../meta');
const plugins = require('../plugins');
const privileges = require('../privileges');
const helpers = require('./helpers');

const controllers = {
        admin: require('../controllers/admin'),
        helpers: require('../controllers/helpers'),
};

const middleware = module.exports;

async function checkprivilegeSet(uid) {
        const privilegeSet = await privileges.admin.get(uid);
        return !Object.values(privilegeSet).some(Boolean);
}

middleware.buildHeader = helpers.try(async (req, res, next) => {
        res.locals.renderAdminHeader = true;
        if (req.method === 'GET') {
                await require('./index').applyCSRFasync(req, res);
        }

        res.locals.config = await controllers.admin.loadConfig(req);
        next();
});

middleware.checkPrivileges = helpers.try(async (req, res, next) => {
        // Kick out guests, obviously
        if (req.uid <= 0) {
                return controllers.helpers.notAllowed(req, res);
        }

        // Otherwise, check for privilege based on page (if not in mapping, deny access)
        const path = req.path.replace(/^(\/api)?(\/v3)?\/admin\/?/g, '');
        if (path) {
                const privilege = privileges.admin.resolve(path);
                if (!await privileges.admin.can(privilege, req.uid)) {
                        return controllers.helpers.notAllowed(req, res);
                }
        } else if (await checkprivilegeSet(req.uid)) {
                // If accessing /admin, check for any valid admin privs
                return controllers.helpers.notAllowed(req, res);
        }
        /* else {
                // If accessing /admin, check for any valid admin privs
                const privilegeSet = await privileges.admin.get(req.uid);
                if (!Object.values(privilegeSet).some(Boolean)) {
                        return controllers.helpers.notAllowed(req, res);
                }
        }
        tested and works! two cognitive complexities removed */

        // If user does not have password
        const hasPassword = await user.hasPassword(req.uid);
        if (!hasPassword) {
                return next();
        }

        // Reject if they need to re-login (due to ACP timeout), otherwise extend logout timer
        const loginTime = req.session.meta ? req.session.meta.datetime : 0;
        const adminReloginDuration = meta.config.adminReloginDuration * 60000;
        const disabled = meta.config.adminReloginDuration === 0;
        if (disabled || (loginTime && parseInt(loginTime, 10) > Date.now() - adminReloginDuration)) {
                const timeLeft = parseInt(loginTime, 10) - (Date.now() - adminReloginDuration);
                if (req.session.meta) {
                        const minimum = Math.min(60000, adminReloginDuration);
                        const factor = Math.min(1, Math.ceil(minimum - Math.min(timeLeft, minimum)));
                        req.session.meta.datetime += minimum * factor;
                }

                return next();
        }
        /* if (disabled || (loginTime && parseInt(loginTime, 10) > Date.now() - adminReloginDuration)) {
                const timeLeft = parseInt(loginTime, 10) - (Date.now() - adminReloginDuration);
                if (req.session.meta && timeLeft < Math.min(60000, adminReloginDuration)) {
                        req.session.meta.datetime += Math.min(60000, adminReloginDuration);
                }

                return next();
        }
        tested and works! one cognitive complexity removed */

        let returnTo = req.path;
        if (nconf.get('relative_path')) {
                returnTo = req.path.replace(new RegExp(`^${nconf.get('relative_path')}`), '');
        }
        returnTo = returnTo.replace(/^\/api/, '');

        req.session.returnTo = returnTo;
        req.session.forceLogin = 1;

        await plugins.hooks.fire('response:auth.relogin', { req, res });
        if (res.headersSent) {
                return;
        }

        if (res.locals.isAPI) {
                controllers.helpers.formatApiResponse(401, res);
                return;
        }
        res.redirect(`${nconf.get('relative_path')}/login?local=1`);
        /* if (res.locals.isAPI) {
                controllers.helpers.formatApiResponse(401, res);
        } else {
                res.redirect(`${nconf.get('relative_path')}/login?local=1`);
        }
        tested and works! one cognitive complexity removed
        */
});

1	'use strict';
2
3
4	const nconf = require('nconf');	1✔
5
6	const user = require('../user');	1✔
7	const meta = require('../meta');	1✔
8	const plugins = require('../plugins');	1✔
9	const privileges = require('../privileges');	1✔
10	const helpers = require('./helpers');	1✔
11
12	const controllers = {	1✔
13	admin: require('../controllers/admin'),
14	helpers: require('../controllers/helpers'),
15	};
16
17	const middleware = module.exports;	1✔
18
19	async function checkprivilegeSet(uid) {
20	const privilegeSet = await privileges.admin.get(uid);	27✔
21	return !Object.values(privilegeSet).some(Boolean);	27✔
22	}
23
24	middleware.buildHeader = helpers.try(async (req, res, next) => {	1✔
25	res.locals.renderAdminHeader = true;	16✔
26	if (req.method === 'GET') {	16!
27	await require('./index').applyCSRFasync(req, res);	16✔
28	}
29
30	res.locals.config = await controllers.admin.loadConfig(req);	16✔
31	next();	16✔
32	});
33
34	middleware.checkPrivileges = helpers.try(async (req, res, next) => {	1✔
35	// Kick out guests, obviously
36	if (req.uid <= 0) {	185!
37	return controllers.helpers.notAllowed(req, res);	×
38	}
39
40	// Otherwise, check for privilege based on page (if not in mapping, deny access)
41	const path = req.path.replace(/^(\/api)?(\/v3)?\/admin\/?/g, '');	185✔
42	if (path) {	185✔
43	const privilege = privileges.admin.resolve(path);	158✔
44	if (!await privileges.admin.can(privilege, req.uid)) {	158✔
45	return controllers.helpers.notAllowed(req, res);	20✔
46	}
47	} else if (await checkprivilegeSet(req.uid)) {	27✔
48	// If accessing /admin, check for any valid admin privs
49	return controllers.helpers.notAllowed(req, res);	13✔
50	}
51	/* else {
52	// If accessing /admin, check for any valid admin privs
53	const privilegeSet = await privileges.admin.get(req.uid);
54	if (!Object.values(privilegeSet).some(Boolean)) {
55	return controllers.helpers.notAllowed(req, res);
56	}
57	}
58	tested and works! two cognitive complexities removed */
59
60	// If user does not have password
61	const hasPassword = await user.hasPassword(req.uid);	152✔
62	if (!hasPassword) {	152!
63	return next();	×
64	}
65
66	// Reject if they need to re-login (due to ACP timeout), otherwise extend logout timer
67	const loginTime = req.session.meta ? req.session.meta.datetime : 0;	152!
68	const adminReloginDuration = meta.config.adminReloginDuration * 60000;	152✔
69	const disabled = meta.config.adminReloginDuration === 0;	152✔
70	if (disabled \|\| (loginTime && parseInt(loginTime, 10) > Date.now() - adminReloginDuration)) {	152!
71	const timeLeft = parseInt(loginTime, 10) - (Date.now() - adminReloginDuration);	152✔
72	if (req.session.meta) {	152!
73	const minimum = Math.min(60000, adminReloginDuration);	152✔
74	const factor = Math.min(1, Math.ceil(minimum - Math.min(timeLeft, minimum)));	152✔
75	req.session.meta.datetime += minimum * factor;	152✔
76	}
77
78	return next();	152✔
79	}
80	/* if (disabled \|\| (loginTime && parseInt(loginTime, 10) > Date.now() - adminReloginDuration)) {
81	const timeLeft = parseInt(loginTime, 10) - (Date.now() - adminReloginDuration);
82	if (req.session.meta && timeLeft < Math.min(60000, adminReloginDuration)) {
83	req.session.meta.datetime += Math.min(60000, adminReloginDuration);
84	}
85
86	return next();
87	}
88	tested and works! one cognitive complexity removed */
89
90	let returnTo = req.path;	×
91	if (nconf.get('relative_path')) {	×
92	returnTo = req.path.replace(new RegExp(`^${nconf.get('relative_path')}`), '');	×
93	}
94	returnTo = returnTo.replace(/^\/api/, '');	×
95
96	req.session.returnTo = returnTo;	×
97	req.session.forceLogin = 1;	×
98
99	await plugins.hooks.fire('response:auth.relogin', { req, res });	×
100	if (res.headersSent) {	×
101	return;	×
102	}
103
104	if (res.locals.isAPI) {	×
105	controllers.helpers.formatApiResponse(401, res);	×
NEW 106	return;	×
107	}
NEW 108	res.redirect(`${nconf.get('relative_path')}/login?local=1`);	×
109	/* if (res.locals.isAPI) {
110	controllers.helpers.formatApiResponse(401, res);
111	} else {
112	res.redirect(`${nconf.get('relative_path')}/login?local=1`);
113	}
114	tested and works! one cognitive complexity removed
115	*/
116	});

CMU-313 / NodeBB / 10727519299

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous