You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
499 lines
17 KiB
JavaScript
499 lines
17 KiB
JavaScript
'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, { ...res.locals.templateValues, ...options }, fn);
|
|
} catch (err) {
|
|
next(err);
|
|
}
|
|
};
|
|
|
|
next();
|
|
};
|
|
|
|
async function getLoggedInUser(req) {
|
|
if (req.user) {
|
|
return await user.getUserData(req.uid);
|
|
}
|
|
return {
|
|
uid: 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;
|
|
}
|
|
|
|
async function loadClientHeaderFooterData(req, res, options) {
|
|
const registrationType = meta.config.registrationType || 'normal';
|
|
res.locals.config = res.locals.config || {};
|
|
const templateValues = {
|
|
title: meta.config.title || '',
|
|
'title:url': meta.config['title:url'] || '',
|
|
description: meta.config.description || '',
|
|
'cache-buster': meta.config['cache-buster'] || '',
|
|
'brand:logo': meta.config['brand:logo'] || '',
|
|
'brand:logo:url': meta.config['brand:logo:url'] || '',
|
|
'brand:logo:alt': meta.config['brand:logo:alt'] || '',
|
|
'brand:logo:display': meta.config['brand:logo'] ? '' : 'hide',
|
|
allowRegistration: registrationType === 'normal',
|
|
searchEnabled: plugins.hooks.hasListeners('filter:search.query'),
|
|
postQueueEnabled: !!meta.config.postQueue,
|
|
config: res.locals.config,
|
|
relative_path,
|
|
bodyClass: options.bodyClass,
|
|
widgets: options.widgets,
|
|
};
|
|
|
|
templateValues.configJSON = jsesc(JSON.stringify(res.locals.config), { isScriptContext: true });
|
|
|
|
const title = translator.unescape(utils.stripHTMLTags(options.title));
|
|
const results = await utils.promiseParallel({
|
|
isAdmin: user.isAdministrator(req.uid),
|
|
isGlobalMod: user.isGlobalModerator(req.uid),
|
|
isModerator: user.isModeratorOfAnyCategory(req.uid),
|
|
privileges: privileges.global.get(req.uid),
|
|
user: user.getUserData(req.uid),
|
|
isEmailConfirmSent: req.uid <= 0 ? false : await user.email.isValidationPending(req.uid),
|
|
languageDirection: translator.translate('[[language:dir]]', res.locals.config.userLang),
|
|
timeagoCode: languages.userTimeagoCode(res.locals.config.userLang),
|
|
browserTitle: translator.translate(controllersHelpers.buildTitle(title)),
|
|
navigation: navigation.get(req.uid),
|
|
roomIds: db.getSortedSetRevRange(`uid:${req.uid}:chat:rooms`, 0, 0),
|
|
});
|
|
|
|
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.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 = (parseInt(meta.config.disableCustomUserSkins, 10) !== 1 ? res.locals.config.bootswatchSkin : '') || meta.config.bootswatchSkin || '';
|
|
templateValues.browserTitle = results.browserTitle;
|
|
({
|
|
navigation: templateValues.navigation,
|
|
unreadCount: templateValues.unreadCount,
|
|
} = await appendUnreadCounts({
|
|
uid: req.uid,
|
|
query: req.query,
|
|
navigation: results.navigation,
|
|
unreadData,
|
|
}));
|
|
templateValues.isAdmin = results.user.isAdmin;
|
|
templateValues.isGlobalMod = results.user.isGlobalMod;
|
|
templateValues.showModMenu = results.user.isAdmin || results.user.isGlobalMod || results.user.isMod;
|
|
templateValues.canChat = results.privileges.chat && meta.config.disableChat !== 1;
|
|
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;
|
|
if (req.query.noScriptMessage) {
|
|
templateValues.noScriptMessage = validator.escape(String(req.query.noScriptMessage));
|
|
}
|
|
|
|
templateValues.template = { name: res.locals.template };
|
|
templateValues.template[res.locals.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);
|
|
}
|
|
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, {}, [], []),
|
|
});
|
|
|
|
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;
|
|
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}`]),
|
|
};
|
|
|
|
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;
|
|
}
|
|
};
|