10713844511

Committed 05 Sep 2024 04:24AM UTC coverage: 82.673% (+0.002%) from 82.671%

Build # 10713844511

Build Type

Pull #527

github

Committed by

web-flow

Commit Message

Merge e3e5d7f7c into e7cfda55c

Pull Request Pull Request #527: Refactored src/controllers/topics.js to reduce its cognitive complexity

Run Details

9967 of 13477 branches covered (73.96%)

Branch coverage included in aggregate %.

26 of 27 new or added lines in 1 file covered. (96.3%)

1 existing line in 1 file now uncovered.

22335 of 25595 relevant lines covered (87.26%)

1631.98 hits per line

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

85.03

/src/controllers/topics.js

'use strict';

const nconf = require('nconf');
const qs = require('querystring');
const validator = require('validator');

const user = require('../user');
const meta = require('../meta');
const topics = require('../topics');
const categories = require('../categories');
const posts = require('../posts');
const privileges = require('../privileges');
const helpers = require('./helpers');
const pagination = require('../pagination');
const utils = require('../utils');
const analytics = require('../analytics');

const topicsController = module.exports;

const url = nconf.get('url');
const relative_path = nconf.get('relative_path');
const upload_url = nconf.get('upload_url');
const validSorts = ['oldest_to_newest', 'newest_to_oldest', 'most_votes'];

topicsController.get = async function getTopic(req, res, next) {
        const tid = req.params.topic_id;

        if (isInvalidRequest(req, tid)) {
                return next();
        }
        let postIndex = parseInt(req.params.post_index, 10) || 1;
        const topicData = await topics.getTopicData(tid);

        if (!topicData) {
                return next();
        }

        const [userPrivileges, settings, rssToken] = await getUserData(req, tid);
        let currentPage = parseInt(req.query.page, 10) || 1;
        const pageCount = Math.max(1, Math.ceil((topicData && topicData.postcount) / settings.postsPerPage));

        if (isAccessRestricted(userPrivileges, topicData, settings, currentPage, pageCount)) {
                return next();
        }

        if (isTopicUnreadable(userPrivileges, topicData)) {
                return helpers.notAllowed(req, res);
        }

        if (await handleSpecialCases(req, res, topicData, tid, postIndex)) {
                return;
        }

        postIndex = Math.max(1, postIndex);
        const sort = getSortOption(req.query.sort, validSorts, settings.topicPostSort);
        const { set, reverse } = getSetAndReverseOptions(sort, tid);

        if (!req.query.page) {
                currentPage = calculatePageFromIndex(postIndex, settings);
        }

        if (settings.usePagination && req.query.page) {
                const top = ((currentPage - 1) * settings.postsPerPage) + 1;
                const bottom = top + settings.postsPerPage;
                if (!req.params.post_index || (postIndex < top || postIndex > bottom)) {
                        postIndex = top;
                }
        }

        const { start, stop } = calculateStartStop(currentPage, postIndex, settings);

        await topics.getTopicWithPosts(topicData, set, req.uid, start, stop, reverse);

        topics.modifyPostsByPrivilege(topicData, userPrivileges);
        topicData.tagWhitelist = categories.filterTagWhitelist(topicData.tagWhitelist, userPrivileges.isAdminOrMod);

        topicData.privileges = userPrivileges;
        topicData.topicStaleDays = meta.config.topicStaleDays;
        topicData['reputation:disabled'] = meta.config['reputation:disabled'];
        topicData['downvote:disabled'] = meta.config['downvote:disabled'];
        topicData.upvoteVisibility = meta.config.upvoteVisibility;
        topicData.downvoteVisibility = meta.config.downvoteVisibility;
        topicData['feeds:disableRSS'] = meta.config['feeds:disableRSS'] || 0;
        topicData['signatures:hideDuplicates'] = meta.config['signatures:hideDuplicates'];
        topicData.bookmarkThreshold = meta.config.bookmarkThreshold;
        topicData.necroThreshold = meta.config.necroThreshold;
        topicData.postEditDuration = meta.config.postEditDuration;
        topicData.postDeleteDuration = meta.config.postDeleteDuration;
        topicData.scrollToMyPost = settings.scrollToMyPost;
        topicData.updateUrlWithPostIndex = settings.updateUrlWithPostIndex;
        topicData.allowMultipleBadges = meta.config.allowMultipleBadges === 1;
        topicData.privateUploads = meta.config.privateUploads === 1;
        topicData.showPostPreviewsOnHover = meta.config.showPostPreviewsOnHover === 1;
        topicData.sortOptionLabel = `[[topic:${validator.escape(String(sort)).replace(/_/g, '-')}]]`;
        if (!meta.config['feeds:disableRSS']) {
                topicData.rssFeedUrl = `${relative_path}/topic/${topicData.tid}.rss`;
                if (req.loggedIn) {
                        topicData.rssFeedUrl += `?uid=${req.uid}&token=${rssToken}`;
                }
        }

        topicData.postIndex = postIndex;

        const [author] = await Promise.all([
                user.getUserFields(topicData.uid, ['username', 'userslug']),
                buildBreadcrumbs(topicData),
                addOldCategory(topicData, userPrivileges),
                addTags(topicData, req, res, currentPage),
                incrementViewCount(req, tid),
                markAsRead(req, tid),
                analytics.increment([`pageviews:byCid:${topicData.category.cid}`]),
        ]);

        topicData.author = author;
        topicData.pagination = pagination.create(currentPage, pageCount, req.query);
        topicData.pagination.rel.forEach((rel) => {
                rel.href = `${url}/topic/${topicData.slug}${rel.href}`;
                res.locals.linkTags.push(rel);
        });
        res.render('topic', topicData);
};

function isInvalidRequest(req, tid) {
        return (
                (req.params.post_index && !utils.isNumber(req.params.post_index) && req.params.post_index !== 'unread') ||
                !utils.isNumber(tid)
        );
}

async function getUserData(req, tid) {
        return Promise.all([
                privileges.topics.get(tid, req.uid),
                user.getSettings(req.uid),
                user.auth.getFeedToken(req.uid),
        ]);
}

function isAccessRestricted(userPrivileges, topicData, settings, currentPage, pageCount) {
        const invalidPagination = (settings.usePagination && (currentPage < 1 || currentPage > pageCount));
        return (
                userPrivileges.disabled ||
                invalidPagination ||
                (topicData.scheduled && !userPrivileges.view_scheduled)
        );
}

function isTopicUnreadable(userPrivileges, topicData) {
        return (!userPrivileges['topics:read'] || (!topicData.scheduled && topicData.deleted && !userPrivileges.view_deleted));
}

async function handleSpecialCases(req, res, topicData, tid, postIndex) {
        if (req.params.post_index === 'unread') {
                postIndex = await topics.getUserBookmark(tid, req.uid);
        }

        if (!res.locals.isAPI && needsSlugRedirect(req, topicData, tid)) {
                helpers.redirect(res, `/topic/${topicData.slug}${postIndex ? `/${postIndex}` : ''}${generateQueryString(req.query)}`, true);
                return true;
        }

        if (isInvalidPostIndex(postIndex, topicData.postcount)) {
                helpers.redirect(res, `/topic/${tid}/${req.params.slug}${postIndex > topicData.postcount ? `/${topicData.postcount}` : ''}${generateQueryString(req.query)}`);
                return true;
        }

        return false;
}

function needsSlugRedirect(req, topicData, tid) {
        return (!req.params.slug || topicData.slug !== `${tid}/${req.params.slug}`) && (topicData.slug && topicData.slug !== `${tid}/`);
}

function isInvalidPostIndex(postIndex, postCount) {
        return utils.isNumber(postIndex) && postCount > 0 && (postIndex < 1 || postIndex > postCount);
}

function getSortOption(requestedSort, validSorts, defaultSort) {
        return validSorts.includes(requestedSort) ? requestedSort : defaultSort;
}

function getSetAndReverseOptions(sort, tid) {
        const isMostVotes = sort === 'most_votes';
        return {
                set: isMostVotes ? `tid:${tid}:posts:votes` : `tid:${tid}:posts`,
                reverse: isMostVotes || sort === 'newest_to_oldest',
        };
}

function generateQueryString(query) {
        const qString = qs.stringify(query);
        return qString.length ? `?${qString}` : '';
}

function calculatePageFromIndex(postIndex, settings) {
        return 1 + Math.floor((postIndex - 1) / settings.postsPerPage);
}

function calculateStartStop(page, postIndex, settings) {
        let startSkip = 0;

        if (!settings.usePagination) {
                if (postIndex > 1) {
                        page = 1;
                }
                startSkip = Math.max(0, postIndex - Math.ceil(settings.postsPerPage / 2));
        }

        const start = ((page - 1) * settings.postsPerPage) + startSkip;
        const stop = start + settings.postsPerPage - 1;
        return { start: Math.max(0, start), stop: Math.max(0, stop) };
}

async function incrementViewCount(req, tid) {
        const allow = req.uid > 0 || (meta.config.guestsIncrementTopicViews && req.uid === 0);
        if (allow) {
                req.session.tids_viewed = req.session.tids_viewed || {};
                const now = Date.now();
                const interval = meta.config.incrementTopicViewsInterval * 60000;
                if (!req.session.tids_viewed[tid] || req.session.tids_viewed[tid] < now - interval) {
                        await topics.increaseViewCount(tid);
                        req.session.tids_viewed[tid] = now;
                }
        }
}

async function markAsRead(req, tid) {
        if (req.loggedIn) {
                const markedRead = await topics.markAsRead([tid], req.uid);
                const promises = [topics.markTopicNotificationsRead([tid], req.uid)];
                if (markedRead) {
                        promises.push(topics.pushUnreadCount(req.uid));
                }
                await Promise.all(promises);
        }
}

async function buildBreadcrumbs(topicData) {
        const breadcrumbs = [
                {
                        text: topicData.category.name,
                        url: `${url}/category/${topicData.category.slug}`,
                        cid: topicData.category.cid,
                },
                {
                        text: topicData.title,
                },
        ];
        const parentCrumbs = await helpers.buildCategoryBreadcrumbs(topicData.category.parentCid);
        topicData.breadcrumbs = parentCrumbs.concat(breadcrumbs);
}

async function addOldCategory(topicData, userPrivileges) {
        if (userPrivileges.isAdminOrMod && topicData.oldCid) {
                topicData.oldCategory = await categories.getCategoryFields(
                        topicData.oldCid, ['cid', 'name', 'icon', 'bgColor', 'color', 'slug']
                );
        }
}

async function addTags(topicData, req, res, currentPage) {
        const postIndex = parseInt(req.params.post_index, 10) || 0;
        const postAtIndex = topicData.posts.find(p => parseInt(p.index, 10) === parseInt(Math.max(0, postIndex - 1), 10));
        let description = '';
        if (postAtIndex && postAtIndex.content) {
                description = utils.stripHTMLTags(utils.decodeHTMLEntities(postAtIndex.content)).trim();
        }

        if (description.length > 160) {
                description = `${description.slice(0, 157)}...`;
        }
        description = description.replace(/\n/g, ' ').trim();

        let mainPost = topicData.posts.find(p => parseInt(p.index, 10) === 0);
        if (!mainPost) {
                mainPost = await posts.getPostData(topicData.mainPid);
        }

        res.locals.metaTags = [
                {
                        name: 'title',
                        content: topicData.titleRaw,
                },
                {
                        property: 'og:title',
                        content: topicData.titleRaw,
                },
                {
                        property: 'og:type',
                        content: 'article',
                },
                {
                        property: 'article:published_time',
                        content: utils.toISOString(topicData.timestamp),
                },
                {
                        property: 'article:modified_time',
                        content: utils.toISOString(Math.max(topicData.lastposttime, mainPost && mainPost.edited)),
                },
                {
                        property: 'article:section',
                        content: topicData.category ? topicData.category.name : '',
                },
        ];

        if (description && description.length) {
                res.locals.metaTags.push(
                        {
                                name: 'description',
                                content: description,
                        },
                        {
                                property: 'og:description',
                                content: description,
                        },
                );
        }

        await addOGImageTags(res, topicData, postAtIndex);

        const page = currentPage > 1 ? `?page=${currentPage}` : '';
        res.locals.linkTags = [
                {
                        rel: 'canonical',
                        href: `${url}/topic/${topicData.slug}${page}`,
                        noEscape: true,
                },
        ];

        if (!topicData['feeds:disableRSS']) {
                res.locals.linkTags.push({
                        rel: 'alternate',
                        type: 'application/rss+xml',
                        href: topicData.rssFeedUrl,
                });
        }

        if (topicData.category) {
                res.locals.linkTags.push({
                        rel: 'up',
                        href: `${url}/category/${topicData.category.slug}`,
                });
        }

        if (postAtIndex) {
                res.locals.linkTags.push({
                        rel: 'author',
                        href: `${url}/user/${postAtIndex.user.userslug}`,
                });
        }
}

async function addOGImageTags(res, topicData, postAtIndex) {
        const uploads = postAtIndex ? await posts.uploads.listWithSizes(postAtIndex.pid) : [];
        const images = uploads.map((upload) => {
                upload.name = `${url + upload_url}/${upload.name}`;
                return upload;
        });
        if (topicData.thumbs) {
                const path = require('path');
                const thumbs = topicData.thumbs.filter(
                        t => t && images.every(img => path.normalize(img.name) !== path.normalize(url + t.url))
                );
                images.push(...thumbs.map(thumbObj => ({ name: url + thumbObj.url })));
        }
        if (topicData.category.backgroundImage && (!postAtIndex || !postAtIndex.index)) {
                images.push(topicData.category.backgroundImage);
        }
        if (postAtIndex && postAtIndex.user && postAtIndex.user.picture) {
                images.push(postAtIndex.user.picture);
        }
        images.forEach(path => addOGImageTag(res, path));
}

function addOGImageTag(res, image) {
        let imageUrl;
        if (typeof image === 'string' && !image.startsWith('http')) {
                imageUrl = url + image.replace(new RegExp(`^${relative_path}`), '');
        } else if (typeof image === 'object') {
                imageUrl = image.name;
        } else {
                imageUrl = image;
        }

        res.locals.metaTags.push({
                property: 'og:image',
                content: imageUrl,
                noEscape: true,
        }, {
                property: 'og:image:url',
                content: imageUrl,
                noEscape: true,
        });

        if (typeof image === 'object' && image.width && image.height) {
                res.locals.metaTags.push({
                        property: 'og:image:width',
                        content: String(image.width),
                }, {
                        property: 'og:image:height',
                        content: String(image.height),
                });
        }
}

topicsController.teaser = async function (req, res, next) {
        const tid = req.params.topic_id;
        if (!utils.isNumber(tid)) {
                return next();
        }
        const canRead = await privileges.topics.can('topics:read', tid, req.uid);
        if (!canRead) {
                return res.status(403).json('[[error:no-privileges]]');
        }
        const pid = await topics.getLatestUndeletedPid(tid);
        if (!pid) {
                return res.status(404).json('not-found');
        }
        const postData = await posts.getPostSummaryByPids([pid], req.uid, { stripTags: false });
        if (!postData.length) {
                return res.status(404).json('not-found');
        }
        res.json(postData[0]);
};

topicsController.pagination = async function (req, res, next) {
        const tid = req.params.topic_id;
        const currentPage = parseInt(req.query.page, 10) || 1;

        if (!utils.isNumber(tid)) {
                return next();
        }
        const topic = await topics.getTopicData(tid);
        if (!topic) {
                return next();
        }
        const [userPrivileges, settings] = await Promise.all([
                privileges.topics.get(tid, req.uid),
                user.getSettings(req.uid),
        ]);

        if (!userPrivileges.read || !privileges.topics.canViewDeletedScheduled(topic, userPrivileges)) {
                return helpers.notAllowed(req, res);
        }

        const postCount = topic.postcount;
        const pageCount = Math.max(1, Math.ceil(postCount / settings.postsPerPage));

        const paginationData = pagination.create(currentPage, pageCount);
        paginationData.rel.forEach((rel) => {
                rel.href = `${url}/topic/${topic.slug}${rel.href}`;
        });

        res.json({ pagination: paginationData });
};

1	'use strict';
2
3	const nconf = require('nconf');	1✔
4	const qs = require('querystring');	1✔
5	const validator = require('validator');	1✔
6
7	const user = require('../user');	1✔
8	const meta = require('../meta');	1✔
9	const topics = require('../topics');	1✔
10	const categories = require('../categories');	1✔
11	const posts = require('../posts');	1✔
12	const privileges = require('../privileges');	1✔
13	const helpers = require('./helpers');	1✔
14	const pagination = require('../pagination');	1✔
15	const utils = require('../utils');	1✔
16	const analytics = require('../analytics');	1✔
17
18	const topicsController = module.exports;	1✔
19
20	const url = nconf.get('url');	1✔
21	const relative_path = nconf.get('relative_path');	1✔
22	const upload_url = nconf.get('upload_url');	1✔
23	const validSorts = ['oldest_to_newest', 'newest_to_oldest', 'most_votes'];	1✔
24
25	topicsController.get = async function getTopic(req, res, next) {	1✔
26	const tid = req.params.topic_id;	32✔
27
28	if (isInvalidRequest(req, tid)) {	32✔
29	return next();	9✔
30	}
31	let postIndex = parseInt(req.params.post_index, 10) \|\| 1;	23✔
32	const topicData = await topics.getTopicData(tid);	23✔
33
34	if (!topicData) {	23✔
35	return next();	2✔
36	}
37
38	const [userPrivileges, settings, rssToken] = await getUserData(req, tid);	21✔
39	let currentPage = parseInt(req.query.page, 10) \|\| 1;	21✔
40	const pageCount = Math.max(1, Math.ceil((topicData && topicData.postcount) / settings.postsPerPage));	21✔
41
42	if (isAccessRestricted(userPrivileges, topicData, settings, currentPage, pageCount)) {	21✔
43	return next();	4✔
44	}
45
46	if (isTopicUnreadable(userPrivileges, topicData)) {	17✔
47	return helpers.notAllowed(req, res);	1✔
48	}
49
50	if (await handleSpecialCases(req, res, topicData, tid, postIndex)) {	16✔
51	return;	3✔
52	}
53
54	postIndex = Math.max(1, postIndex);	13✔
55	const sort = getSortOption(req.query.sort, validSorts, settings.topicPostSort);	13✔
56	const { set, reverse } = getSetAndReverseOptions(sort, tid);	13✔
57
58	if (!req.query.page) {	13✔
59	currentPage = calculatePageFromIndex(postIndex, settings);	12✔
60	}
61
62	if (settings.usePagination && req.query.page) {	13!
63	const top = ((currentPage - 1) * settings.postsPerPage) + 1;	×
64	const bottom = top + settings.postsPerPage;	×
65	if (!req.params.post_index \|\| (postIndex < top \|\| postIndex > bottom)) {	×
66	postIndex = top;	×
67	}
68	}
69
70	const { start, stop } = calculateStartStop(currentPage, postIndex, settings);	13✔
71
72	await topics.getTopicWithPosts(topicData, set, req.uid, start, stop, reverse);	13✔
73
74	topics.modifyPostsByPrivilege(topicData, userPrivileges);	13✔
75	topicData.tagWhitelist = categories.filterTagWhitelist(topicData.tagWhitelist, userPrivileges.isAdminOrMod);	13✔
76
77	topicData.privileges = userPrivileges;	13✔
78	topicData.topicStaleDays = meta.config.topicStaleDays;	13✔
79	topicData['reputation:disabled'] = meta.config['reputation:disabled'];	13✔
80	topicData['downvote:disabled'] = meta.config['downvote:disabled'];	13✔
81	topicData.upvoteVisibility = meta.config.upvoteVisibility;	13✔
82	topicData.downvoteVisibility = meta.config.downvoteVisibility;	13✔
83	topicData['feeds:disableRSS'] = meta.config['feeds:disableRSS'] \|\| 0;	13✔
84	topicData['signatures:hideDuplicates'] = meta.config['signatures:hideDuplicates'];	13✔
85	topicData.bookmarkThreshold = meta.config.bookmarkThreshold;	13✔
86	topicData.necroThreshold = meta.config.necroThreshold;	13✔
87	topicData.postEditDuration = meta.config.postEditDuration;	13✔
88	topicData.postDeleteDuration = meta.config.postDeleteDuration;	13✔
89	topicData.scrollToMyPost = settings.scrollToMyPost;	13✔
90	topicData.updateUrlWithPostIndex = settings.updateUrlWithPostIndex;	13✔
91	topicData.allowMultipleBadges = meta.config.allowMultipleBadges === 1;	13✔
92	topicData.privateUploads = meta.config.privateUploads === 1;	13✔
93	topicData.showPostPreviewsOnHover = meta.config.showPostPreviewsOnHover === 1;	13✔
94	topicData.sortOptionLabel = `[[topic:${validator.escape(String(sort)).replace(/_/g, '-')}]]`;	13✔
95	if (!meta.config['feeds:disableRSS']) {	13!
96	topicData.rssFeedUrl = `${relative_path}/topic/${topicData.tid}.rss`;	13✔
97	if (req.loggedIn) {	13✔
98	topicData.rssFeedUrl += `?uid=${req.uid}&token=${rssToken}`;	6✔
99	}
100	}
101
102	topicData.postIndex = postIndex;	13✔
103
104	const [author] = await Promise.all([	13✔
105	user.getUserFields(topicData.uid, ['username', 'userslug']),
106	buildBreadcrumbs(topicData),
107	addOldCategory(topicData, userPrivileges),
108	addTags(topicData, req, res, currentPage),
109	incrementViewCount(req, tid),
110	markAsRead(req, tid),
111	analytics.increment([`pageviews:byCid:${topicData.category.cid}`]),
112	]);
113
114	topicData.author = author;	13✔
115	topicData.pagination = pagination.create(currentPage, pageCount, req.query);	13✔
116	topicData.pagination.rel.forEach((rel) => {	13✔
117	rel.href = `${url}/topic/${topicData.slug}${rel.href}`;	×
118	res.locals.linkTags.push(rel);	×
119	});
120	res.render('topic', topicData);	13✔
121	};
122
123	function isInvalidRequest(req, tid) {
124	return (	32✔
125	(req.params.post_index && !utils.isNumber(req.params.post_index) && req.params.post_index !== 'unread') \|\|	70✔
126	!utils.isNumber(tid)
127	);
128	}
129
130	async function getUserData(req, tid) {
131	return Promise.all([	21✔
132	privileges.topics.get(tid, req.uid),
133	user.getSettings(req.uid),
134	user.auth.getFeedToken(req.uid),
135	]);
136	}
137
138	function isAccessRestricted(userPrivileges, topicData, settings, currentPage, pageCount) {
139	const invalidPagination = (settings.usePagination && (currentPage < 1 \|\| currentPage > pageCount));	21✔
140	return (	21✔
141	userPrivileges.disabled \|\|	66✔
142	invalidPagination \|\|
143	(topicData.scheduled && !userPrivileges.view_scheduled)
144	);
145	}
146
147	function isTopicUnreadable(userPrivileges, topicData) {
148	return (!userPrivileges['topics:read'] \|\| (!topicData.scheduled && topicData.deleted && !userPrivileges.view_deleted));	17✔
149	}
150
151	async function handleSpecialCases(req, res, topicData, tid, postIndex) {
152	if (req.params.post_index === 'unread') {	16!
NEW 153	postIndex = await topics.getUserBookmark(tid, req.uid);	×
154	}
155
156	if (!res.locals.isAPI && needsSlugRedirect(req, topicData, tid)) {	16✔
157	helpers.redirect(res, `/topic/${topicData.slug}${postIndex ? `/${postIndex}` : ''}${generateQueryString(req.query)}`, true);	2!
158	return true;	2✔
159	}
160
161	if (isInvalidPostIndex(postIndex, topicData.postcount)) {	14✔
162	helpers.redirect(res, `/topic/${tid}/${req.params.slug}${postIndex > topicData.postcount ? `/${topicData.postcount}` : ''}${generateQueryString(req.query)}`);	1!
163	return true;	1✔
164	}
165
166	return false;	13✔
167	}
168
169	function needsSlugRedirect(req, topicData, tid) {
170	return (!req.params.slug \|\| topicData.slug !== `${tid}/${req.params.slug}`) && (topicData.slug && topicData.slug !== `${tid}/`);	8✔
171	}
172
173	function isInvalidPostIndex(postIndex, postCount) {
174	return utils.isNumber(postIndex) && postCount > 0 && (postIndex < 1 \|\| postIndex > postCount);	14✔
175	}
176
177	function getSortOption(requestedSort, validSorts, defaultSort) {
178	return validSorts.includes(requestedSort) ? requestedSort : defaultSort;	13!
179	}
180
181	function getSetAndReverseOptions(sort, tid) {
182	const isMostVotes = sort === 'most_votes';	13✔
183	return {	13✔
184	set: isMostVotes ? `tid:${tid}:posts:votes` : `tid:${tid}:posts`,	13!
185	reverse: isMostVotes \|\| sort === 'newest_to_oldest',	26✔
186	};
187	}
188
189	function generateQueryString(query) {
190	const qString = qs.stringify(query);	3✔
191	return qString.length ? `?${qString}` : '';	3✔
192	}
193
194	function calculatePageFromIndex(postIndex, settings) {
195	return 1 + Math.floor((postIndex - 1) / settings.postsPerPage);	12✔
196	}
197
198	function calculateStartStop(page, postIndex, settings) {
199	let startSkip = 0;	13✔
200
201	if (!settings.usePagination) {	13✔
202	if (postIndex > 1) {	8!
203	page = 1;	×
204	}
205	startSkip = Math.max(0, postIndex - Math.ceil(settings.postsPerPage / 2));	8✔
206	}
207
208	const start = ((page - 1) * settings.postsPerPage) + startSkip;	13✔
209	const stop = start + settings.postsPerPage - 1;	13✔
210	return { start: Math.max(0, start), stop: Math.max(0, stop) };	13✔
211	}
212
213	async function incrementViewCount(req, tid) {
214	const allow = req.uid > 0 \|\| (meta.config.guestsIncrementTopicViews && req.uid === 0);	13✔
215	if (allow) {	13!
216	req.session.tids_viewed = req.session.tids_viewed \|\| {};	13✔
217	const now = Date.now();	13✔
218	const interval = meta.config.incrementTopicViewsInterval * 60000;	13✔
219	if (!req.session.tids_viewed[tid] \|\| req.session.tids_viewed[tid] < now - interval) {	13✔
220	await topics.increaseViewCount(tid);	12✔
221	req.session.tids_viewed[tid] = now;	12✔
222	}
223	}
224	}
225
226	async function markAsRead(req, tid) {
227	if (req.loggedIn) {	13✔
228	const markedRead = await topics.markAsRead([tid], req.uid);	6✔
229	const promises = [topics.markTopicNotificationsRead([tid], req.uid)];	6✔
230	if (markedRead) {	6✔
231	promises.push(topics.pushUnreadCount(req.uid));	3✔
232	}
233	await Promise.all(promises);	6✔
234	}
235	}
236
237	async function buildBreadcrumbs(topicData) {
238	const breadcrumbs = [	13✔
239	{
240	text: topicData.category.name,
241	url: `${url}/category/${topicData.category.slug}`,
242	cid: topicData.category.cid,
243	},
244	{
245	text: topicData.title,
246	},
247	];
248	const parentCrumbs = await helpers.buildCategoryBreadcrumbs(topicData.category.parentCid);	13✔
249	topicData.breadcrumbs = parentCrumbs.concat(breadcrumbs);	13✔
250	}
251
252	async function addOldCategory(topicData, userPrivileges) {
253	if (userPrivileges.isAdminOrMod && topicData.oldCid) {	13!
254	topicData.oldCategory = await categories.getCategoryFields(	×
255	topicData.oldCid, ['cid', 'name', 'icon', 'bgColor', 'color', 'slug']
256	);
257	}
258	}
259
260	async function addTags(topicData, req, res, currentPage) {
261	const postIndex = parseInt(req.params.post_index, 10) \|\| 0;	13✔
262	const postAtIndex = topicData.posts.find(p => parseInt(p.index, 10) === parseInt(Math.max(0, postIndex - 1), 10));	13✔
263	let description = '';	13✔
264	if (postAtIndex && postAtIndex.content) {	13✔
265	description = utils.stripHTMLTags(utils.decodeHTMLEntities(postAtIndex.content)).trim();	11✔
266	}
267
268	if (description.length > 160) {	13!
269	description = `${description.slice(0, 157)}...`;	×
270	}
271	description = description.replace(/\n/g, ' ').trim();	13✔
272
273	let mainPost = topicData.posts.find(p => parseInt(p.index, 10) === 0);	13✔
274	if (!mainPost) {	13✔
275	mainPost = await posts.getPostData(topicData.mainPid);	2✔
276	}
277
278	res.locals.metaTags = [	13✔
279	{
280	name: 'title',
281	content: topicData.titleRaw,
282	},
283	{
284	property: 'og:title',
285	content: topicData.titleRaw,
286	},
287	{
288	property: 'og:type',
289	content: 'article',
290	},
291	{
292	property: 'article:published_time',
293	content: utils.toISOString(topicData.timestamp),
294	},
295	{
296	property: 'article:modified_time',
297	content: utils.toISOString(Math.max(topicData.lastposttime, mainPost && mainPost.edited)),	25✔
298	},
299	{
300	property: 'article:section',
301	content: topicData.category ? topicData.category.name : '',	13!
302	},
303	];
304
305	if (description && description.length) {	13✔
306	res.locals.metaTags.push(	11✔
307	{
308	name: 'description',
309	content: description,
310	},
311	{
312	property: 'og:description',
313	content: description,
314	},
315	);
316	}
317
318	await addOGImageTags(res, topicData, postAtIndex);	13✔
319
320	const page = currentPage > 1 ? `?page=${currentPage}` : '';	13✔
321	res.locals.linkTags = [	13✔
322	{
323	rel: 'canonical',
324	href: `${url}/topic/${topicData.slug}${page}`,
325	noEscape: true,
326	},
327	];
328
329	if (!topicData['feeds:disableRSS']) {	13!
330	res.locals.linkTags.push({	13✔
331	rel: 'alternate',
332	type: 'application/rss+xml',
333	href: topicData.rssFeedUrl,
334	});
335	}
336
337	if (topicData.category) {	13!
338	res.locals.linkTags.push({	13✔
339	rel: 'up',
340	href: `${url}/category/${topicData.category.slug}`,
341	});
342	}
343
344	if (postAtIndex) {	13✔
345	res.locals.linkTags.push({	11✔
346	rel: 'author',
347	href: `${url}/user/${postAtIndex.user.userslug}`,
348	});
349	}
350	}
351
352	async function addOGImageTags(res, topicData, postAtIndex) {
353	const uploads = postAtIndex ? await posts.uploads.listWithSizes(postAtIndex.pid) : [];	13✔
354	const images = uploads.map((upload) => {	13✔
355	upload.name = `${url + upload_url}/${upload.name}`;	×
356	return upload;	×
357	});
358	if (topicData.thumbs) {	13!
359	const path = require('path');	13✔
360	const thumbs = topicData.thumbs.filter(	13✔
361	t => t && images.every(img => path.normalize(img.name) !== path.normalize(url + t.url))	×
362	);
363	images.push(...thumbs.map(thumbObj => ({ name: url + thumbObj.url })));	13✔
364	}
365	if (topicData.category.backgroundImage && (!postAtIndex \|\| !postAtIndex.index)) {	13!
366	images.push(topicData.category.backgroundImage);	×
367	}
368	if (postAtIndex && postAtIndex.user && postAtIndex.user.picture) {	13✔
369	images.push(postAtIndex.user.picture);	1✔
370	}
371	images.forEach(path => addOGImageTag(res, path));	13✔
372	}
373
374	function addOGImageTag(res, image) {
375	let imageUrl;
376	if (typeof image === 'string' && !image.startsWith('http')) {	1!
377	imageUrl = url + image.replace(new RegExp(`^${relative_path}`), '');	1✔
378	} else if (typeof image === 'object') {	×
379	imageUrl = image.name;	×
380	} else {
381	imageUrl = image;	×
382	}
383
384	res.locals.metaTags.push({	1✔
385	property: 'og:image',
386	content: imageUrl,
387	noEscape: true,
388	}, {
389	property: 'og:image:url',
390	content: imageUrl,
391	noEscape: true,
392	});
393
394	if (typeof image === 'object' && image.width && image.height) {	1!
395	res.locals.metaTags.push({	×
396	property: 'og:image:width',
397	content: String(image.width),
398	}, {
399	property: 'og:image:height',
400	content: String(image.height),
401	});
402	}
403	}
404
405	topicsController.teaser = async function (req, res, next) {	1✔
406	const tid = req.params.topic_id;	4✔
407	if (!utils.isNumber(tid)) {	4✔
408	return next();	1✔
409	}
410	const canRead = await privileges.topics.can('topics:read', tid, req.uid);	3✔
411	if (!canRead) {	3✔
412	return res.status(403).json('[[error:no-privileges]]');	1✔
413	}
414	const pid = await topics.getLatestUndeletedPid(tid);	2✔
415	if (!pid) {	2!
416	return res.status(404).json('not-found');	×
417	}
418	const postData = await posts.getPostSummaryByPids([pid], req.uid, { stripTags: false });	2✔
419	if (!postData.length) {	2!
420	return res.status(404).json('not-found');	×
421	}
422	res.json(postData[0]);	2✔
423	};
424
425	topicsController.pagination = async function (req, res, next) {	1✔
426	const tid = req.params.topic_id;	4✔
427	const currentPage = parseInt(req.query.page, 10) \|\| 1;	4✔
428
429	if (!utils.isNumber(tid)) {	4✔
430	return next();	1✔
431	}
432	const topic = await topics.getTopicData(tid);	3✔
433	if (!topic) {	3✔
434	return next();	1✔
435	}
436	const [userPrivileges, settings] = await Promise.all([	2✔
437	privileges.topics.get(tid, req.uid),
438	user.getSettings(req.uid),
439	]);
440
441	if (!userPrivileges.read \|\| !privileges.topics.canViewDeletedScheduled(topic, userPrivileges)) {	2!
442	return helpers.notAllowed(req, res);	×
443	}
444
445	const postCount = topic.postcount;	2✔
446	const pageCount = Math.max(1, Math.ceil(postCount / settings.postsPerPage));	2✔
447
448	const paginationData = pagination.create(currentPage, pageCount);	2✔
449	paginationData.rel.forEach((rel) => {	2✔
450	rel.href = `${url}/topic/${topic.slug}${rel.href}`;	×
451	});
452
453	res.json({ pagination: paginationData });	2✔
454	};

CMU-313 / NodeBB / 10713844511

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