10690319133

Committed 03 Sep 2024 08:42PM UTC coverage: 82.671%. Remained the same

Build # 10690319133

Build Type

Pull #425

github

Committed by

web-flow

Commit Message

Merge a35c581cb into e7cfda55c

Pull Request Pull Request #425: Refactoring code in src/middleware/render.js

Run Details

9964 of 13473 branches covered (73.96%)

Branch coverage included in aggregate %.

15 of 15 new or added lines in 1 file covered. (100.0%)

13 existing lines in 1 file now uncovered.

22323 of 25582 relevant lines covered (87.26%)

1632.79 hits per line

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

79.13

/src/middleware/render.js

'use strict';

const _ = require('lodash');
const nconf = require('nconf');
const validator = require('validator');
const jsesc = require('jsesc');
const winston = require('winston');
const semver = require('semver');

const db = require('../database');
const navigation = require('../navigation');
const translator = require('../translator');
const privileges = require('../privileges');
const languages = require('../languages');
const plugins = require('../plugins');
const user = require('../user');
const topics = require('../topics');
const messaging = require('../messaging');
const flags = require('../flags');
const meta = require('../meta');
const widgets = require('../widgets');
const utils = require('../utils');
const helpers = require('./helpers');
const versions = require('../admin/versions');
const controllersHelpers = require('../controllers/helpers');

const relative_path = nconf.get('relative_path');

module.exports = function (middleware) {
        middleware.processRender = function processRender(req, res, next) {
                // res.render post-processing, modified from here: https://gist.github.com/mrlannigan/5051687
                const { render } = res;

                res.render = async function renderOverride(template, options, fn) {
                        const self = this;
                        const { req } = this;
                        async function renderMethod(template, options, fn) {
                                options = options || {};
                                if (typeof options === 'function') {
                                        fn = options;
                                        options = {};
                                }

                                options.loggedIn = req.uid > 0;
                                options.loggedInUser = await getLoggedInUser(req);
                                options.relative_path = relative_path;
                                options.template = { name: template, [template]: true };
                                options.url = (req.baseUrl + req.path.replace(/^\/api/, ''));
                                options.bodyClass = helpers.buildBodyClass(req, res, options);

                                if (req.loggedIn) {
                                        res.set('cache-control', 'private');
                                }

                                const buildResult = await plugins.hooks.fire(`filter:${template}.build`, {
                                        req: req,
                                        res: res,
                                        templateData: options,
                                });
                                if (res.headersSent) {
                                        return;
                                }
                                const templateToRender = buildResult.templateData.templateToRender || template;

                                const renderResult = await plugins.hooks.fire('filter:middleware.render', {
                                        req: req,
                                        res: res,
                                        templateData: buildResult.templateData,
                                });
                                if (res.headersSent) {
                                        return;
                                }
                                options = renderResult.templateData;
                                options._header = {
                                        tags: await meta.tags.parse(req, renderResult, res.locals.metaTags, res.locals.linkTags),
                                };
                                options.widgets = await widgets.render(req.uid, {
                                        template: `${template}.tpl`,
                                        url: options.url,
                                        templateData: options,
                                        req: req,
                                        res: res,
                                });
                                res.locals.template = template;
                                options._locals = undefined;

                                if (res.locals.isAPI) {
                                        if (req.route && req.route.path === '/api/') {
                                                options.title = '[[pages:home]]';
                                        }
                                        req.app.set('json spaces', global.env === 'development' || req.query.pretty ? 4 : 0);
                                        return res.json(options);
                                }
                                const optionsString = JSON.stringify(options).replace(/<\//g, '<\\/');
                                const headerFooterData = await loadHeaderFooterData(req, res, options);
                                const results = await utils.promiseParallel({
                                        header: renderHeaderFooter('renderHeader', req, res, options, headerFooterData),
                                        content: renderContent(render, templateToRender, req, res, options),
                                        footer: renderHeaderFooter('renderFooter', req, res, options, headerFooterData),
                                });

                                const str = `${results.header +
                                        (res.locals.postHeader || '') +
                                        results.content
                                }<script id="ajaxify-data" type="application/json">${
                                        optionsString
                                }</script>${
                                        res.locals.preFooter || ''
                                }${results.footer}`;

                                if (typeof fn !== 'function') {
                                        self.send(str);
                                } else {
                                        fn(null, str);
                                }
                        }

                        try {
                                await renderMethod(template, options, fn);
                        } catch (err) {
                                next(err);
                        }
                };

                next();
        };

        async function getLoggedInUser(req) {
                if (req.user) {
                        return await user.getUserData(req.uid);
                }
                return {
                        uid: req.uid === -1 ? -1 : 0,
                        username: '[[global:guest]]',
                        picture: user.getDefaultAvatar(),
                        'icon:text': '?',
                        'icon:bgColor': '#aaa',
                };
        }

        async function loadHeaderFooterData(req, res, options) {
                if (res.locals.renderHeader) {
                        return await loadClientHeaderFooterData(req, res, options);
                } else if (res.locals.renderAdminHeader) {
                        return await loadAdminHeaderFooterData(req, res, options);
                }
                return null;
        }

        function initializeTemplateValues(metaConfig, resLocalsConfig, registrationType, options) {
                return {
                        title: metaConfig.title || '',
                        'title:url': metaConfig['title:url'] || '',
                        description: metaConfig.description || '',
                        'cache-buster': metaConfig['cache-buster'] || '',
                        'brand:logo': metaConfig['brand:logo'] || '',
                        'brand:logo:url': metaConfig['brand:logo:url'] || '',
                        'brand:logo:alt': metaConfig['brand:logo:alt'] || '',
                        'brand:logo:display': metaConfig['brand:logo'] ? '' : 'hide',
                        allowRegistration: registrationType === 'normal',
                        searchEnabled: plugins.hooks.hasListeners('filter:search.query'),
                        postQueueEnabled: !!metaConfig.postQueue,
                        registrationQueueEnabled: metaConfig.registrationApprovalType !== 'normal' ||
                        ['invite-only', 'admin-invite-only'].includes(registrationType),
                        config: resLocalsConfig,
                        relative_path,
                        bodyClass: options.bodyClass,
                        widgets: options.widgets,
                        configJSON: jsesc(JSON.stringify(resLocalsConfig), { isScriptContext: true }),
                };
        }

        async function fetchUserData(reqUid, optionsTitle, userLang) {
                const title = utils.stripHTMLTags(optionsTitle || '');
                return await utils.promiseParallel({
                        isAdmin: user.isAdministrator(reqUid),
                        isGlobalMod: user.isGlobalModerator(reqUid),
                        isModerator: user.isModeratorOfAnyCategory(reqUid),
                        privileges: privileges.global.get(reqUid),
                        blocks: user.blocks.list(reqUid),
                        user: user.getUserData(reqUid),
                        isEmailConfirmSent: reqUid <= 0 ? false : await user.email.isValidationPending(reqUid),
                        languageDirection: translator.translate('[[language:dir]]', userLang),
                        timeagoCode: languages.userTimeagoCode(userLang),
                        browserTitle: translator.translate(controllersHelpers.buildTitle(translator.unescape(title))),
                        navigation: navigation.get(reqUid),
                        roomIds: reqUid > 0 ? db.getSortedSetRevRange(`uid:${reqUid}:chat:rooms`, 0, 0) : [],
                });
        }

        function assignToTemplate(results, templateValues, res) {
                const unreadData = {
                        '': {},
                        new: {},
                        watched: {},
                        unreplied: {},
                };

                results.user.unreadData = unreadData;
                results.user.isAdmin = results.isAdmin;
                results.user.isGlobalMod = results.isGlobalMod;
                results.user.isMod = !!results.isModerator;
                results.user.privileges = results.privileges;
                results.user.blocks = results.blocks;
                results.user.timeagoCode = results.timeagoCode;
                results.user[results.user.status] = true;
                results.user.lastRoomId = results.roomIds.length ? results.roomIds[0] : null;

                results.user.email = String(results.user.email);
                results.user['email:confirmed'] = results.user['email:confirmed'] === 1;
                results.user.isEmailConfirmSent = !!results.isEmailConfirmSent;

                templateValues.bootswatchSkin = res.locals.config.bootswatchSkin || '';
                templateValues.browserTitle = results.browserTitle;
                templateValues.user = results.user;
                templateValues.userJSON = jsesc(JSON.stringify(results.user), { isScriptContext: true });
                templateValues.useCustomCSS = meta.config.useCustomCSS && meta.config.customCSS;
                templateValues.customCSS = templateValues.useCustomCSS ? (meta.config.renderedCustomCSS || '') : '';
                templateValues.useCustomHTML = meta.config.useCustomHTML;
                templateValues.customHTML = templateValues.useCustomHTML ? meta.config.customHTML : '';
                templateValues.maintenanceHeader = meta.config.maintenanceMode && !results.isAdmin;
                templateValues.defaultLang = meta.config.defaultLang || 'en-GB';
                templateValues.userLang = res.locals.config.userLang;
                templateValues.languageDirection = results.languageDirection;
        }

        function handleConditionalTemplateAssignments(req, templateValues, options, resLocals) {
                if (req.query.noScriptMessage) {
                        templateValues.noScriptMessage = validator.escape(String(req.query.noScriptMessage));
                }

                templateValues.template = { name: resLocals.template };
                templateValues.template[resLocals.template] = true;

                if (options.hasOwnProperty('_header')) {
                        templateValues.metaTags = options._header.tags.meta;
                        templateValues.linkTags = options._header.tags.link;
                }

                if (req.route && req.route.path === '/') {
                        modifyTitle(templateValues);
                }
        }

        async function loadClientHeaderFooterData(req, res, options) {
                const registrationType = meta.config.registrationType || 'normal';
                res.locals.config = res.locals.config || {};
                const templateValues = initializeTemplateValues(meta.config, res.locals.config, registrationType, options);
                const results = await fetchUserData(req.uid, options.title, res.locals.config.userLang);
                assignToTemplate(results, templateValues, res);
                await appendUnreadCounts({
                        uid: req.uid,
                        query: req.query,
                        navigation: results.navigation,
                        unreadData: results.user.unreadData,
                }).then(({ navigation, unreadCount }) => {
                        Object.assign(templateValues, {
                                navigation,
                                unreadCount,
                                isAdmin: results.user.isAdmin,
                                isGlobalMod: results.user.isGlobalMod,
                                showModMenu: results.user.isAdmin || results.user.isGlobalMod || results.user.isMod,
                                canChat: (results.privileges.chat || results.privileges['chat:privileged']) && meta.config.disableChat !== 1,
                        });
                });
                handleConditionalTemplateAssignments(req, templateValues, options, res.locals);
                return templateValues;
        }

        async function loadAdminHeaderFooterData(req, res, options) {
                const custom_header = {
                        plugins: [],
                        authentication: [],
                };
                res.locals.config = res.locals.config || {};

                const results = await utils.promiseParallel({
                        userData: user.getUserFields(req.uid, ['username', 'userslug', 'email', 'picture', 'email:confirmed']),
                        scripts: getAdminScripts(),
                        custom_header: plugins.hooks.fire('filter:admin.header.build', custom_header),
                        configs: meta.configs.list(),
                        latestVersion: getLatestVersion(),
                        privileges: privileges.admin.get(req.uid),
                        tags: meta.tags.parse(req, {}, [], []),
                        languageDirection: translator.translate('[[language:dir]]', res.locals.config.acpLang),
                });

                const { userData } = results;
                userData.uid = req.uid;
                userData['email:confirmed'] = userData['email:confirmed'] === 1;
                userData.privileges = results.privileges;

                let acpPath = req.path.slice(1).split('/');
                acpPath.forEach((path, i) => {
                        acpPath[i] = path.charAt(0).toUpperCase() + path.slice(1);
                });
                acpPath = acpPath.join(' > ');

                const version = nconf.get('version');

                res.locals.config.userLang = res.locals.config.acpLang || res.locals.config.userLang;
                res.locals.config.isRTL = results.languageDirection === 'rtl';
                const templateValues = {
                        config: res.locals.config,
                        configJSON: jsesc(JSON.stringify(res.locals.config), { isScriptContext: true }),
                        relative_path: res.locals.config.relative_path,
                        adminConfigJSON: encodeURIComponent(JSON.stringify(results.configs)),
                        metaTags: results.tags.meta,
                        linkTags: results.tags.link,
                        user: userData,
                        userJSON: jsesc(JSON.stringify(userData), { isScriptContext: true }),
                        plugins: results.custom_header.plugins,
                        authentication: results.custom_header.authentication,
                        scripts: results.scripts,
                        'cache-buster': meta.config['cache-buster'] || '',
                        env: !!process.env.NODE_ENV,
                        title: `${acpPath || 'Dashboard'} | NodeBB Admin Control Panel`,
                        bodyClass: options.bodyClass,
                        version: version,
                        latestVersion: results.latestVersion,
                        upgradeAvailable: results.latestVersion && semver.gt(results.latestVersion, version),
                        showManageMenu: results.privileges.superadmin || ['categories', 'privileges', 'users', 'admins-mods', 'groups', 'tags', 'settings'].some(priv => results.privileges[`admin:${priv}`]),
                        defaultLang: meta.config.defaultLang || 'en-GB',
                        acpLang: res.locals.config.acpLang,
                        languageDirection: results.languageDirection,
                };

                templateValues.template = { name: res.locals.template };
                templateValues.template[res.locals.template] = true;
                return templateValues;
        }

        function renderContent(render, tpl, req, res, options) {
                return new Promise((resolve, reject) => {
                        render.call(res, tpl, options, async (err, str) => {
                                if (err) reject(err);
                                else resolve(await translate(str, getLang(req, res)));
                        });
                });
        }

        async function renderHeader(req, res, options, headerFooterData) {
                const hookReturn = await plugins.hooks.fire('filter:middleware.renderHeader', {
                        req: req,
                        res: res,
                        templateValues: headerFooterData, // TODO: deprecate
                        templateData: headerFooterData,
                        data: options,
                });

                return await req.app.renderAsync('header', hookReturn.templateData);
        }

        async function renderFooter(req, res, options, headerFooterData) {
                const hookReturn = await plugins.hooks.fire('filter:middleware.renderFooter', {
                        req,
                        res,
                        templateValues: headerFooterData, // TODO: deprecate
                        templateData: headerFooterData,
                        data: options,
                });

                const scripts = await plugins.hooks.fire('filter:scripts.get', []);

                hookReturn.templateData.scripts = scripts.map(script => ({ src: script }));

                hookReturn.templateData.useCustomJS = meta.config.useCustomJS;
                hookReturn.templateData.customJS = hookReturn.templateData.useCustomJS ? meta.config.customJS : '';
                hookReturn.templateData.isSpider = req.uid === -1;

                return await req.app.renderAsync('footer', hookReturn.templateData);
        }

        async function renderAdminHeader(req, res, options, headerFooterData) {
                const hookReturn = await plugins.hooks.fire('filter:middleware.renderAdminHeader', {
                        req,
                        res,
                        templateValues: headerFooterData, // TODO: deprecate
                        templateData: headerFooterData,
                        data: options,
                });

                return await req.app.renderAsync('admin/header', hookReturn.templateData);
        }

        async function renderAdminFooter(req, res, options, headerFooterData) {
                const hookReturn = await plugins.hooks.fire('filter:middleware.renderAdminFooter', {
                        req,
                        res,
                        templateValues: headerFooterData, // TODO: deprecate
                        templateData: headerFooterData,
                        data: options,
                });

                return await req.app.renderAsync('admin/footer', hookReturn.templateData);
        }

        async function renderHeaderFooter(method, req, res, options, headerFooterData) {
                let str = '';
                if (res.locals.renderHeader) {
                        if (method === 'renderHeader') {
                                str = await renderHeader(req, res, options, headerFooterData);
                        } else if (method === 'renderFooter') {
                                str = await renderFooter(req, res, options, headerFooterData);
                        }
                } else if (res.locals.renderAdminHeader) {
                        if (method === 'renderHeader') {
                                str = await renderAdminHeader(req, res, options, headerFooterData);
                        } else if (method === 'renderFooter') {
                                str = await renderAdminFooter(req, res, options, headerFooterData);
                        }
                }
                return await translate(str, getLang(req, res));
        }

        function getLang(req, res) {
                let language = (res.locals.config && res.locals.config.userLang) || 'en-GB';
                if (res.locals.renderAdminHeader) {
                        language = (res.locals.config && res.locals.config.acpLang) || 'en-GB';
                }
                return req.query.lang ? validator.escape(String(req.query.lang)) : language;
        }

        async function translate(str, language) {
                const translated = await translator.translate(str, language);
                return translator.unescape(translated);
        }

        async function appendUnreadCounts({ uid, navigation, unreadData, query }) {
                const originalRoutes = navigation.map(nav => nav.originalRoute);
                const calls = {
                        unreadData: topics.getUnreadData({ uid: uid, query: query }),
                        unreadChatCount: messaging.getUnreadCount(uid),
                        unreadNotificationCount: user.notifications.getUnreadCount(uid),
                        unreadFlagCount: (async function () {
                                if (originalRoutes.includes('/flags') && await user.isPrivileged(uid)) {
                                        return flags.getCount({
                                                uid,
                                                query,
                                                filters: {
                                                        quick: 'unresolved',
                                                        cid: (await user.isAdminOrGlobalMod(uid)) ? [] : (await user.getModeratedCids(uid)),
                                                },
                                        });
                                }
                                return 0;
                        }()),
                };
                const results = await utils.promiseParallel(calls);

                const unreadCounts = results.unreadData.counts;
                const unreadCount = {
                        topic: unreadCounts[''] || 0,
                        newTopic: unreadCounts.new || 0,
                        watchedTopic: unreadCounts.watched || 0,
                        unrepliedTopic: unreadCounts.unreplied || 0,
                        mobileUnread: 0,
                        unreadUrl: '/unread',
                        chat: results.unreadChatCount || 0,
                        notification: results.unreadNotificationCount || 0,
                        flags: results.unreadFlagCount || 0,
                };

                Object.keys(unreadCount).forEach((key) => {
                        if (unreadCount[key] > 99) {
                                unreadCount[key] = '99+';
                        }
                });

                const { tidsByFilter } = results.unreadData;
                navigation = navigation.map((item) => {
                        function modifyNavItem(item, route, filter, content) {
                                if (item && item.originalRoute === route) {
                                        unreadData[filter] = _.zipObject(tidsByFilter[filter], tidsByFilter[filter].map(() => true));
                                        item.content = content;
                                        unreadCount.mobileUnread = content;
                                        unreadCount.unreadUrl = route;
                                        if (unreadCounts[filter] > 0) {
                                                item.iconClass += ' unread-count';
                                        }
                                }
                        }
                        modifyNavItem(item, '/unread', '', unreadCount.topic);
                        modifyNavItem(item, '/unread?filter=new', 'new', unreadCount.newTopic);
                        modifyNavItem(item, '/unread?filter=watched', 'watched', unreadCount.watchedTopic);
                        modifyNavItem(item, '/unread?filter=unreplied', 'unreplied', unreadCount.unrepliedTopic);

                        ['flags'].forEach((prop) => {
                                if (item && item.originalRoute === `/${prop}` && unreadCount[prop] > 0) {
                                        item.iconClass += ' unread-count';
                                        item.content = unreadCount.flags;
                                }
                        });

                        return item;
                });

                return { navigation, unreadCount };
        }


        function modifyTitle(obj) {
                const title = controllersHelpers.buildTitle(meta.config.homePageTitle || '[[pages:home]]');
                obj.browserTitle = title;

                if (obj.metaTags) {
                        obj.metaTags.forEach((tag, i) => {
                                if (tag.property === 'og:title') {
                                        obj.metaTags[i].content = title;
                                }
                        });
                }

                return title;
        }

        async function getAdminScripts() {
                const scripts = await plugins.hooks.fire('filter:admin.scripts.get', []);
                return scripts.map(script => ({ src: script }));
        }

        async function getLatestVersion() {
                try {
                        return await versions.getLatestVersion();
                } catch (err) {
                        winston.error(`[acp] Failed to fetch latest version${err.stack}`);
                }
                return null;
        }
};

1	'use strict';
2
3	const _ = require('lodash');	1✔
4	const nconf = require('nconf');	1✔
5	const validator = require('validator');	1✔
6	const jsesc = require('jsesc');	1✔
7	const winston = require('winston');	1✔
8	const semver = require('semver');	1✔
9
10	const db = require('../database');	1✔
11	const navigation = require('../navigation');	1✔
12	const translator = require('../translator');	1✔
13	const privileges = require('../privileges');	1✔
14	const languages = require('../languages');	1✔
15	const plugins = require('../plugins');	1✔
16	const user = require('../user');	1✔
17	const topics = require('../topics');	1✔
18	const messaging = require('../messaging');	1✔
19	const flags = require('../flags');	1✔
20	const meta = require('../meta');	1✔
21	const widgets = require('../widgets');	1✔
22	const utils = require('../utils');	1✔
23	const helpers = require('./helpers');	1✔
24	const versions = require('../admin/versions');	1✔
25	const controllersHelpers = require('../controllers/helpers');	1✔
26
27	const relative_path = nconf.get('relative_path');	1✔
28
29	module.exports = function (middleware) {	1✔
30	middleware.processRender = function processRender(req, res, next) {	1✔
31	// res.render post-processing, modified from here: https://gist.github.com/mrlannigan/5051687
32	const { render } = res;	1,215✔
33
34	res.render = async function renderOverride(template, options, fn) {	1,215✔
35	const self = this;	315✔
36	const { req } = this;	315✔
37	async function renderMethod(template, options, fn) {
38	options = options \|\| {};	315!
39	if (typeof options === 'function') {	315!
40	fn = options;	×
41	options = {};	×
42	}
43
44	options.loggedIn = req.uid > 0;	315✔
45	options.loggedInUser = await getLoggedInUser(req);	315✔
46	options.relative_path = relative_path;	315✔
47	options.template = { name: template, [template]: true };	315✔
48	options.url = (req.baseUrl + req.path.replace(/^\/api/, ''));	315✔
49	options.bodyClass = helpers.buildBodyClass(req, res, options);	315✔
50
51	if (req.loggedIn) {	315✔
52	res.set('cache-control', 'private');	238✔
53	}
54
55	const buildResult = await plugins.hooks.fire(`filter:${template}.build`, {	315✔
56	req: req,
57	res: res,
58	templateData: options,
59	});
60	if (res.headersSent) {	315!
61	return;	×
62	}
63	const templateToRender = buildResult.templateData.templateToRender \|\| template;	315✔
64
65	const renderResult = await plugins.hooks.fire('filter:middleware.render', {	315✔
66	req: req,
67	res: res,
68	templateData: buildResult.templateData,
69	});
70	if (res.headersSent) {	315!
71	return;	×
72	}
73	options = renderResult.templateData;	315✔
74	options._header = {	315✔
75	tags: await meta.tags.parse(req, renderResult, res.locals.metaTags, res.locals.linkTags),
76	};
77	options.widgets = await widgets.render(req.uid, {	315✔
78	template: `${template}.tpl`,
79	url: options.url,
80	templateData: options,
81	req: req,
82	res: res,
83	});
84	res.locals.template = template;	315✔
85	options._locals = undefined;	315✔
86
87	if (res.locals.isAPI) {	315✔
88	if (req.route && req.route.path === '/api/') {	254✔
89	options.title = '[[pages:home]]';	1✔
90	}
91	req.app.set('json spaces', global.env === 'development' \|\| req.query.pretty ? 4 : 0);	254!
92	return res.json(options);	254✔
93	}
94	const optionsString = JSON.stringify(options).replace(/<\//g, '<\\/');	61✔
95	const headerFooterData = await loadHeaderFooterData(req, res, options);	61✔
96	const results = await utils.promiseParallel({	61✔
97	header: renderHeaderFooter('renderHeader', req, res, options, headerFooterData),
98	content: renderContent(render, templateToRender, req, res, options),
99	footer: renderHeaderFooter('renderFooter', req, res, options, headerFooterData),
100	});
101
102	const str = `${results.header +	61✔
103	(res.locals.postHeader \|\| '') +	122✔
104	results.content
105	}<script id="ajaxify-data" type="application/json">${
106	optionsString
107	}</script>${
108	res.locals.preFooter \|\| ''	122✔
109	}${results.footer}`;
110
111	if (typeof fn !== 'function') {	61!
112	self.send(str);	61✔
113	} else {
114	fn(null, str);	×
115	}
116	}
117
118	try {	315✔
119	await renderMethod(template, options, fn);	315✔
120	} catch (err) {
121	next(err);	×
122	}
123	};
124
125	next();	1,215✔
126	};
127
128	async function getLoggedInUser(req) {
129	if (req.user) {	315✔
130	return await user.getUserData(req.uid);	238✔
131	}
132	return {	77✔
133	uid: req.uid === -1 ? -1 : 0,	77!
134	username: '[[global:guest]]',
135	picture: user.getDefaultAvatar(),
136	'icon:text': '?',
137	'icon:bgColor': '#aaa',
138	};
139	}
140
141	async function loadHeaderFooterData(req, res, options) {
142	if (res.locals.renderHeader) {	61✔
143	return await loadClientHeaderFooterData(req, res, options);	45✔
144	} else if (res.locals.renderAdminHeader) {	16!
145	return await loadAdminHeaderFooterData(req, res, options);	16✔
146	}
147	return null;	×
148	}
149
150	function initializeTemplateValues(metaConfig, resLocalsConfig, registrationType, options) {
151	return {	45✔
152	title: metaConfig.title \|\| '',	45!
153	'title:url': metaConfig['title:url'] \|\| '',	90✔
154	description: metaConfig.description \|\| '',	90✔
155	'cache-buster': metaConfig['cache-buster'] \|\| '',	45!
156	'brand:logo': metaConfig['brand:logo'] \|\| '',	90✔
157	'brand:logo:url': metaConfig['brand:logo:url'] \|\| '',	90✔
158	'brand:logo:alt': metaConfig['brand:logo:alt'] \|\| '',	90✔
159	'brand:logo:display': metaConfig['brand:logo'] ? '' : 'hide',	45!
160	allowRegistration: registrationType === 'normal',
161	searchEnabled: plugins.hooks.hasListeners('filter:search.query'),
162	postQueueEnabled: !!metaConfig.postQueue,
163	registrationQueueEnabled: metaConfig.registrationApprovalType !== 'normal' \|\|	90✔
164	['invite-only', 'admin-invite-only'].includes(registrationType),
165	config: resLocalsConfig,
166	relative_path,
167	bodyClass: options.bodyClass,
168	widgets: options.widgets,
169	configJSON: jsesc(JSON.stringify(resLocalsConfig), { isScriptContext: true }),
170	};
171	}
172
173	async function fetchUserData(reqUid, optionsTitle, userLang) {
174	const title = utils.stripHTMLTags(optionsTitle \|\| '');	45✔
175	return await utils.promiseParallel({	45✔
176	isAdmin: user.isAdministrator(reqUid),
177	isGlobalMod: user.isGlobalModerator(reqUid),
178	isModerator: user.isModeratorOfAnyCategory(reqUid),
179	privileges: privileges.global.get(reqUid),
180	blocks: user.blocks.list(reqUid),
181	user: user.getUserData(reqUid),
182	isEmailConfirmSent: reqUid <= 0 ? false : await user.email.isValidationPending(reqUid),	45✔
183	languageDirection: translator.translate('[[language:dir]]', userLang),
184	timeagoCode: languages.userTimeagoCode(userLang),
185	browserTitle: translator.translate(controllersHelpers.buildTitle(translator.unescape(title))),
186	navigation: navigation.get(reqUid),
187	roomIds: reqUid > 0 ? db.getSortedSetRevRange(`uid:${reqUid}:chat:rooms`, 0, 0) : [],	45✔
188	});
189	}
190
191	function assignToTemplate(results, templateValues, res) {
192	const unreadData = {	45✔
193	'': {},
194	new: {},
195	watched: {},
196	unreplied: {},
197	};
198
199	results.user.unreadData = unreadData;	45✔
200	results.user.isAdmin = results.isAdmin;	45✔
201	results.user.isGlobalMod = results.isGlobalMod;	45✔
202	results.user.isMod = !!results.isModerator;	45✔
203	results.user.privileges = results.privileges;	45✔
204	results.user.blocks = results.blocks;	45✔
205	results.user.timeagoCode = results.timeagoCode;	45✔
206	results.user[results.user.status] = true;	45✔
207	results.user.lastRoomId = results.roomIds.length ? results.roomIds[0] : null;	45!
208
209	results.user.email = String(results.user.email);	45✔
210	results.user['email:confirmed'] = results.user['email:confirmed'] === 1;	45✔
211	results.user.isEmailConfirmSent = !!results.isEmailConfirmSent;	45✔
212
213	templateValues.bootswatchSkin = res.locals.config.bootswatchSkin \|\| '';	45✔
214	templateValues.browserTitle = results.browserTitle;	45✔
215	templateValues.user = results.user;	45✔
216	templateValues.userJSON = jsesc(JSON.stringify(results.user), { isScriptContext: true });	45✔
217	templateValues.useCustomCSS = meta.config.useCustomCSS && meta.config.customCSS;	45!
218	templateValues.customCSS = templateValues.useCustomCSS ? (meta.config.renderedCustomCSS \|\| '') : '';	45!
219	templateValues.useCustomHTML = meta.config.useCustomHTML;	45✔
220	templateValues.customHTML = templateValues.useCustomHTML ? meta.config.customHTML : '';	45!
221	templateValues.maintenanceHeader = meta.config.maintenanceMode && !results.isAdmin;	45✔
222	templateValues.defaultLang = meta.config.defaultLang \|\| 'en-GB';	45!
223	templateValues.userLang = res.locals.config.userLang;	45✔
224	templateValues.languageDirection = results.languageDirection;	45✔
225	}
226
227	function handleConditionalTemplateAssignments(req, templateValues, options, resLocals) {
228	if (req.query.noScriptMessage) {	45!
229	templateValues.noScriptMessage = validator.escape(String(req.query.noScriptMessage));	×
230	}
231
232	templateValues.template = { name: resLocals.template };	45✔
233	templateValues.template[resLocals.template] = true;	45✔
234
235	if (options.hasOwnProperty('_header')) {	45!
236	templateValues.metaTags = options._header.tags.meta;	45✔
237	templateValues.linkTags = options._header.tags.link;	45✔
238	}
239
240	if (req.route && req.route.path === '/') {	45✔
241	modifyTitle(templateValues);	1✔
242	}
243	}
244
245	async function loadClientHeaderFooterData(req, res, options) {
246	const registrationType = meta.config.registrationType \|\| 'normal';	45!
247	res.locals.config = res.locals.config \|\| {};	45!
248	const templateValues = initializeTemplateValues(meta.config, res.locals.config, registrationType, options);	45✔
249	const results = await fetchUserData(req.uid, options.title, res.locals.config.userLang);	45✔
250	assignToTemplate(results, templateValues, res);	45✔
251	await appendUnreadCounts({	45✔
252	uid: req.uid,
253	query: req.query,
254	navigation: results.navigation,
255	unreadData: results.user.unreadData,
256	}).then(({ navigation, unreadCount }) => {
257	Object.assign(templateValues, {	45✔
258	navigation,
259	unreadCount,
260	isAdmin: results.user.isAdmin,
261	isGlobalMod: results.user.isGlobalMod,
262	showModMenu: results.user.isAdmin \|\| results.user.isGlobalMod \|\| results.user.isMod,	129✔
263	canChat: (results.privileges.chat \|\| results.privileges['chat:privileged']) && meta.config.disableChat !== 1,	90✔
264	});
265	});
266	handleConditionalTemplateAssignments(req, templateValues, options, res.locals);	45✔
267	return templateValues;	45✔
268	}
269
270	async function loadAdminHeaderFooterData(req, res, options) {
271	const custom_header = {	16✔
272	plugins: [],
273	authentication: [],
274	};
275	res.locals.config = res.locals.config \|\| {};	16!
276
277	const results = await utils.promiseParallel({	16✔
278	userData: user.getUserFields(req.uid, ['username', 'userslug', 'email', 'picture', 'email:confirmed']),
279	scripts: getAdminScripts(),
280	custom_header: plugins.hooks.fire('filter:admin.header.build', custom_header),
281	configs: meta.configs.list(),
282	latestVersion: getLatestVersion(),
283	privileges: privileges.admin.get(req.uid),
284	tags: meta.tags.parse(req, {}, [], []),
285	languageDirection: translator.translate('[[language:dir]]', res.locals.config.acpLang),
286	});
287
288	const { userData } = results;	16✔
289	userData.uid = req.uid;	16✔
290	userData['email:confirmed'] = userData['email:confirmed'] === 1;	16✔
291	userData.privileges = results.privileges;	16✔
292
293	let acpPath = req.path.slice(1).split('/');	16✔
294	acpPath.forEach((path, i) => {	16✔
295	acpPath[i] = path.charAt(0).toUpperCase() + path.slice(1);	46✔
296	});
297	acpPath = acpPath.join(' > ');	16✔
298
299	const version = nconf.get('version');	16✔
300
301	res.locals.config.userLang = res.locals.config.acpLang \|\| res.locals.config.userLang;	16!
302	res.locals.config.isRTL = results.languageDirection === 'rtl';	16✔
303	const templateValues = {	16✔
304	config: res.locals.config,
305	configJSON: jsesc(JSON.stringify(res.locals.config), { isScriptContext: true }),
306	relative_path: res.locals.config.relative_path,
307	adminConfigJSON: encodeURIComponent(JSON.stringify(results.configs)),
308	metaTags: results.tags.meta,
309	linkTags: results.tags.link,
310	user: userData,
311	userJSON: jsesc(JSON.stringify(userData), { isScriptContext: true }),
312	plugins: results.custom_header.plugins,
313	authentication: results.custom_header.authentication,
314	scripts: results.scripts,
315	'cache-buster': meta.config['cache-buster'] \|\| '',	16!
316	env: !!process.env.NODE_ENV,
317	title: `${acpPath \|\| 'Dashboard'} \| NodeBB Admin Control Panel`,	16!
318	bodyClass: options.bodyClass,
319	version: version,
320	latestVersion: results.latestVersion,
321	upgradeAvailable: results.latestVersion && semver.gt(results.latestVersion, version),	32✔
UNCOV 322	showManageMenu: results.privileges.superadmin \|\| ['categories', 'privileges', 'users', 'admins-mods', 'groups', 'tags', 'settings'].some(priv => results.privileges[`admin:${priv}`]),	×
323	defaultLang: meta.config.defaultLang \|\| 'en-GB',	16!
324	acpLang: res.locals.config.acpLang,
325	languageDirection: results.languageDirection,
326	};
327
328	templateValues.template = { name: res.locals.template };	16✔
329	templateValues.template[res.locals.template] = true;	16✔
330	return templateValues;	16✔
331	}
332
333	function renderContent(render, tpl, req, res, options) {
334	return new Promise((resolve, reject) => {	61✔
335	render.call(res, tpl, options, async (err, str) => {	61✔
336	if (err) reject(err);	61!
337	else resolve(await translate(str, getLang(req, res)));	61✔
338	});
339	});
340	}
341
342	async function renderHeader(req, res, options, headerFooterData) {
343	const hookReturn = await plugins.hooks.fire('filter:middleware.renderHeader', {	45✔
344	req: req,
345	res: res,
346	templateValues: headerFooterData, // TODO: deprecate
347	templateData: headerFooterData,
348	data: options,
349	});
350
351	return await req.app.renderAsync('header', hookReturn.templateData);	45✔
352	}
353
354	async function renderFooter(req, res, options, headerFooterData) {
355	const hookReturn = await plugins.hooks.fire('filter:middleware.renderFooter', {	45✔
356	req,
357	res,
358	templateValues: headerFooterData, // TODO: deprecate
359	templateData: headerFooterData,
360	data: options,
361	});
362
363	const scripts = await plugins.hooks.fire('filter:scripts.get', []);	45✔
364
365	hookReturn.templateData.scripts = scripts.map(script => ({ src: script }));	45✔
366
367	hookReturn.templateData.useCustomJS = meta.config.useCustomJS;	45✔
368	hookReturn.templateData.customJS = hookReturn.templateData.useCustomJS ? meta.config.customJS : '';	45!
369	hookReturn.templateData.isSpider = req.uid === -1;	45✔
370
371	return await req.app.renderAsync('footer', hookReturn.templateData);	45✔
372	}
373
374	async function renderAdminHeader(req, res, options, headerFooterData) {
375	const hookReturn = await plugins.hooks.fire('filter:middleware.renderAdminHeader', {	16✔
376	req,
377	res,
378	templateValues: headerFooterData, // TODO: deprecate
379	templateData: headerFooterData,
380	data: options,
381	});
382
383	return await req.app.renderAsync('admin/header', hookReturn.templateData);	16✔
384	}
385
386	async function renderAdminFooter(req, res, options, headerFooterData) {
387	const hookReturn = await plugins.hooks.fire('filter:middleware.renderAdminFooter', {	16✔
388	req,
389	res,
390	templateValues: headerFooterData, // TODO: deprecate
391	templateData: headerFooterData,
392	data: options,
393	});
394
395	return await req.app.renderAsync('admin/footer', hookReturn.templateData);	16✔
396	}
397
398	async function renderHeaderFooter(method, req, res, options, headerFooterData) {
399	let str = '';	122✔
400	if (res.locals.renderHeader) {	122✔
401	if (method === 'renderHeader') {	90✔
402	str = await renderHeader(req, res, options, headerFooterData);	45✔
403	} else if (method === 'renderFooter') {	45!
404	str = await renderFooter(req, res, options, headerFooterData);	45✔
405	}
406	} else if (res.locals.renderAdminHeader) {	32!
407	if (method === 'renderHeader') {	32✔
408	str = await renderAdminHeader(req, res, options, headerFooterData);	16✔
409	} else if (method === 'renderFooter') {	16!
410	str = await renderAdminFooter(req, res, options, headerFooterData);	16✔
411	}
412	}
413	return await translate(str, getLang(req, res));	122✔
414	}
415
416	function getLang(req, res) {
417	let language = (res.locals.config && res.locals.config.userLang) \|\| 'en-GB';	183!
418	if (res.locals.renderAdminHeader) {	183✔
419	language = (res.locals.config && res.locals.config.acpLang) \|\| 'en-GB';	48!
420	}
421	return req.query.lang ? validator.escape(String(req.query.lang)) : language;	183!
422	}
423
424	async function translate(str, language) {
425	const translated = await translator.translate(str, language);	183✔
426	return translator.unescape(translated);	183✔
427	}
428
429	async function appendUnreadCounts({ uid, navigation, unreadData, query }) {
430	const originalRoutes = navigation.map(nav => nav.originalRoute);	45✔
431	const calls = {	45✔
432	unreadData: topics.getUnreadData({ uid: uid, query: query }),
433	unreadChatCount: messaging.getUnreadCount(uid),
434	unreadNotificationCount: user.notifications.getUnreadCount(uid),
435	unreadFlagCount: (async function () {
436	if (originalRoutes.includes('/flags') && await user.isPrivileged(uid)) {	45!
UNCOV 437	return flags.getCount({	×
438	uid,
439	query,
440	filters: {
441	quick: 'unresolved',
442	cid: (await user.isAdminOrGlobalMod(uid)) ? [] : (await user.getModeratedCids(uid)),	×
443	},
444	});
445	}
446	return 0;	45✔
447	}()),
448	};
449	const results = await utils.promiseParallel(calls);	45✔
450
451	const unreadCounts = results.unreadData.counts;	45✔
452	const unreadCount = {	45✔
453	topic: unreadCounts[''] \|\| 0,	83✔
454	newTopic: unreadCounts.new \|\| 0,	83✔
455	watchedTopic: unreadCounts.watched \|\| 0,	89✔
456	unrepliedTopic: unreadCounts.unreplied \|\| 0,	83✔
457	mobileUnread: 0,
458	unreadUrl: '/unread',
459	chat: results.unreadChatCount \|\| 0,	90✔
460	notification: results.unreadNotificationCount \|\| 0,	83✔
461	flags: results.unreadFlagCount \|\| 0,	90✔
462	};
463
464	Object.keys(unreadCount).forEach((key) => {	45✔
465	if (unreadCount[key] > 99) {	405!
UNCOV 466	unreadCount[key] = '99+';	×
467	}
468	});
469
470	const { tidsByFilter } = results.unreadData;	45✔
471	navigation = navigation.map((item) => {	45✔
472	function modifyNavItem(item, route, filter, content) {
UNCOV 473	if (item && item.originalRoute === route) {	×
UNCOV 474	unreadData[filter] = _.zipObject(tidsByFilter[filter], tidsByFilter[filter].map(() => true));	×
UNCOV 475	item.content = content;	×
476	unreadCount.mobileUnread = content;	×
477	unreadCount.unreadUrl = route;	×
478	if (unreadCounts[filter] > 0) {	×
479	item.iconClass += ' unread-count';	×
480	}
481	}
482	}
UNCOV 483	modifyNavItem(item, '/unread', '', unreadCount.topic);	×
UNCOV 484	modifyNavItem(item, '/unread?filter=new', 'new', unreadCount.newTopic);	×
UNCOV 485	modifyNavItem(item, '/unread?filter=watched', 'watched', unreadCount.watchedTopic);	×
486	modifyNavItem(item, '/unread?filter=unreplied', 'unreplied', unreadCount.unrepliedTopic);	×
487
488	['flags'].forEach((prop) => {	×
489	if (item && item.originalRoute === `/${prop}` && unreadCount[prop] > 0) {	×
UNCOV 490	item.iconClass += ' unread-count';	×
491	item.content = unreadCount.flags;	×
492	}
493	});
494
UNCOV 495	return item;	×
496	});
497
498	return { navigation, unreadCount };	45✔
499	}
500
501
502	function modifyTitle(obj) {
503	const title = controllersHelpers.buildTitle(meta.config.homePageTitle \|\| '[[pages:home]]');	1✔
504	obj.browserTitle = title;	1✔
505
506	if (obj.metaTags) {	1!
507	obj.metaTags.forEach((tag, i) => {	1✔
508	if (tag.property === 'og:title') {	13✔
509	obj.metaTags[i].content = title;	1✔
510	}
511	});
512	}
513
514	return title;	1✔
515	}
516
517	async function getAdminScripts() {
518	const scripts = await plugins.hooks.fire('filter:admin.scripts.get', []);	16✔
519	return scripts.map(script => ({ src: script }));	16✔
520	}
521
522	async function getLatestVersion() {
523	try {	16✔
524	return await versions.getLatestVersion();	16✔
525	} catch (err) {
UNCOV 526	winston.error(`[acp] Failed to fetch latest version${err.stack}`);	×
527	}
UNCOV 528	return null;	×
529	}
530	};

CMU-313 / NodeBB / 10690319133

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