6290725310

Committed 24 Sep 2023 02:49PM UTC coverage: 84.968% (-0.03%) from 84.994%

Build # 6290725310

Build Type

Pull #20

github

Committed by

web-flow

Commit Message

Merge bba4c06c0 into f702ae44e

Pull Request Pull Request #20: Anon2

Run Details

10219 of 13265 branches covered (0.0%)

Branch coverage included in aggregate %.

5 of 14 new or added lines in 4 files covered. (35.71%)

2 existing lines in 1 file now uncovered.

22606 of 25367 relevant lines covered (89.12%)

3116.69 hits per line

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

94.74

/src/topics/index.js

'use strict';

const _ = require('lodash');
const validator = require('validator');

const db = require('../database');
const posts = require('../posts');
const utils = require('../utils');
const plugins = require('../plugins');
const meta = require('../meta');
const user = require('../user');
const categories = require('../categories');
const privileges = require('../privileges');
const social = require('../social');

const Topics = module.exports;

require('./data')(Topics);
require('./create')(Topics);
require('./delete')(Topics);
require('./sorted')(Topics);
require('./unread')(Topics);
require('./recent')(Topics);
require('./user')(Topics);
require('./fork')(Topics);
require('./posts')(Topics);
require('./follow')(Topics);
require('./tags')(Topics);
require('./teaser')(Topics);
Topics.scheduled = require('./scheduled');
require('./suggested')(Topics);
require('./tools')(Topics);
Topics.thumbs = require('./thumbs');
require('./bookmarks')(Topics);
require('./merge')(Topics);
Topics.events = require('./events');

Topics.exists = async function (tids) {
    return await db.exists(
        Array.isArray(tids) ? tids.map(tid => `topic:${tid}`) : `topic:${tids}`
    );
};

Topics.getTopicsFromSet = async function (set, uid, start, stop) {
    const tids = await db.getSortedSetRevRange(set, start, stop);
    const topics = await Topics.getTopics(tids, uid);
    Topics.calculateTopicIndices(topics, start);
    return { topics: topics, nextStart: stop + 1 };
};

Topics.getTopics = async function (tids, options) {
    let uid = options;
    if (typeof options === 'object') {
        uid = options.uid;
    }

    tids = await privileges.topics.filterTids('topics:read', tids, uid);
    return await Topics.getTopicsByTids(tids, options);
};

Topics.getTopicsByTids = async function (tids, options) {
    if (!Array.isArray(tids) || !tids.length) {
        return [];
    }
    let uid = options;
    if (typeof options === 'object') {
        uid = options.uid;
    }

    async function loadTopics() {
        const topics = await Topics.getTopicsData(tids);
        const uids = _.uniq(topics.map(t => t && t.uid && t.uid.toString()).filter(v => utils.isNumber(v)));
        const cids = _.uniq(topics.map(t => t && t.cid && t.cid.toString()).filter(v => utils.isNumber(v)));
        const guestTopics = topics.filter(t => t && t.uid === 0);

        async function loadGuestHandles() {
            const mainPids = guestTopics.map(t => t.mainPid);
            const postData = await posts.getPostsFields(mainPids, ['handle']);
            return postData.map(p => p.handle);
        }

        async function loadShowfullnameSettings() {
            if (meta.config.hideFullname) {
                return uids.map(() => ({ showfullname: false }));
            }
            const data = await db.getObjectsFields(uids.map(uid => `user:${uid}:settings`), ['showfullname']);
            data.forEach((settings) => {
                settings.showfullname = parseInt(settings.showfullname, 10) === 1;
            });
            return data;
        }

        const [teasers, users, userSettings, categoriesData, guestHandles, thumbs] = await Promise.all([
            Topics.getTeasers(topics, options),
            user.getUsersFields(uids, ['uid', 'username', 'fullname', 'userslug', 'reputation', 'postcount', 'picture', 'signature', 'banned', 'status']),
            loadShowfullnameSettings(),
            categories.getCategoriesFields(cids, ['cid', 'name', 'slug', 'icon', 'backgroundImage', 'imageClass', 'bgColor', 'color', 'disabled']),
            loadGuestHandles(),
            Topics.thumbs.load(topics),
        ]);

        users.forEach((userObj, idx) => {
            // Hide fullname if needed
            if (!userSettings[idx].showfullname) {
                userObj.fullname = undefined;
            }
        });

        return {
            topics,
            teasers,
            usersMap: _.zipObject(uids, users),
            categoriesMap: _.zipObject(cids, categoriesData),
            tidToGuestHandle: _.zipObject(guestTopics.map(t => t.tid), guestHandles),
            thumbs,
        };
    }

    const [result, hasRead, isIgnored, bookmarks, callerSettings] = await Promise.all([
        loadTopics(),
        Topics.hasReadTopics(tids, uid),
        Topics.isIgnoring(tids, uid),
        Topics.getUserBookmarks(tids, uid),
        user.getSettings(uid),
    ]);

    const sortNewToOld = callerSettings.topicPostSort === 'newest_to_oldest';
    result.topics.forEach((topic, i) => {
        if (topic) {
            topic.thumbs = result.thumbs[i];
            topic.category = result.categoriesMap[topic.cid];
            topic.user = topic.uid ? result.usersMap[topic.uid] : { ...result.usersMap[topic.uid] };
            if (result.tidToGuestHandle[topic.tid]) {
                topic.user.username = validator.escape(result.tidToGuestHandle[topic.tid]);
                topic.user.displayname = topic.user.username;
            }
            topic.teaser = result.teasers[i] || null;
            topic.isOwner = topic.uid === parseInt(uid, 10);
            topic.ignored = isIgnored[i];
            topic.unread = parseInt(uid, 10) <= 0 || (!hasRead[i] && !isIgnored[i]);
            topic.bookmark = sortNewToOld ?
                Math.max(1, topic.postcount + 2 - bookmarks[i]) :
                Math.min(topic.postcount, bookmarks[i] + 1);
            topic.unreplied = !topic.teaser;

            topic.icons = [];
        }
    });

    const filteredTopics = result.topics.filter(topic => topic && topic.category && !topic.category.disabled);

    const hookResult = await plugins.hooks.fire('filter:topics.get', { topics: filteredTopics, uid: uid });
    return hookResult.topics;
};

Topics.getTopicWithPosts = async function (topicData, set, uid, start, stop, reverse) {
    const [
        posts,
        category,
        tagWhitelist,
        threadTools,
        followData,
        bookmark,
        postSharing,
        deleter,
        merger,
        related,
        thumbs,
        events,
    ] = await Promise.all([
        Topics.getTopicPosts(topicData, set, start, stop, uid, reverse),
        categories.getCategoryData(topicData.cid),
        categories.getTagWhitelist([topicData.cid]),
        plugins.hooks.fire('filter:topic.thread_tools', { topic: topicData, uid: uid, tools: [] }),
        Topics.getFollowData([topicData.tid], uid),
        Topics.getUserBookmark(topicData.tid, uid),
        social.getActivePostSharing(),
        getDeleter(topicData),
        getMerger(topicData),
        Topics.getRelatedTopics(topicData, uid),
        Topics.thumbs.load([topicData]),
        Topics.events.get(topicData.tid, uid, reverse),
    ]);

    topicData.thumbs = thumbs[0];
    topicData.posts = posts;
    topicData.events = events;
    topicData.posts.forEach((p) => {
        p.events = events.filter(
            event => event.timestamp >= p.eventStart && event.timestamp < p.eventEnd
        );
    });

    topicData.category = category;
    topicData.tagWhitelist = tagWhitelist[0];
    topicData.minTags = category.minTags;
    topicData.maxTags = category.maxTags;
    topicData.thread_tools = threadTools.tools;
    topicData.isFollowing = followData[0].following;
    topicData.isNotFollowing = !followData[0].following && !followData[0].ignoring;
    topicData.isIgnoring = followData[0].ignoring;
    topicData.bookmark = bookmark;
    topicData.postSharing = postSharing;
    topicData.deleter = deleter;
    if (deleter) {
        topicData.deletedTimestampISO = utils.toISOString(topicData.deletedTimestamp);
    }
    topicData.merger = merger;
    if (merger) {
        topicData.mergedTimestampISO = utils.toISOString(topicData.mergedTimestamp);
    }

    if (topicData.isAnonymous === 'true') {
        topicData.user = {
            username: 'anon',
            displayname: 'anon',
            isAnonymous: topicData.isAnonymous,
        };
        topicData.uid = -1;
    }
    // If  isAnonymous it sets the user property to an anonymous user object with a username and display name of 'anon',
    // and it also sets the uid property to -1 to indicate that this is an anonymous user.


    topicData.related = related || [];
    topicData.unreplied = topicData.postcount === 1;
    topicData.icons = [];

    const result = await plugins.hooks.fire('filter:topic.get', { topic: topicData, uid: uid });
    return result.topic;
};

async function getDeleter(topicData) {
    if (!parseInt(topicData.deleterUid, 10)) {
        return null;
    }
    return await user.getUserFields(topicData.deleterUid, ['username', 'userslug', 'picture']);
}

async function getMerger(topicData) {
    if (!parseInt(topicData.mergerUid, 10)) {
        return null;
    }
    const [
        merger,
        mergedIntoTitle,
    ] = await Promise.all([
        user.getUserFields(topicData.mergerUid, ['username', 'userslug', 'picture']),
        Topics.getTopicField(topicData.mergeIntoTid, 'title'),
    ]);
    merger.mergedIntoTitle = mergedIntoTitle;
    return merger;
}

Topics.getMainPost = async function (tid, uid) {
    const mainPosts = await Topics.getMainPosts([tid], uid);
    return Array.isArray(mainPosts) && mainPosts.length ? mainPosts[0] : null;
};

Topics.getMainPids = async function (tids) {
    if (!Array.isArray(tids) || !tids.length) {
        return [];
    }
    const topicData = await Topics.getTopicsFields(tids, ['mainPid']);
    return topicData.map(topic => topic && topic.mainPid);
};

Topics.getMainPosts = async function (tids, uid) {
    const mainPids = await Topics.getMainPids(tids);
    return await getMainPosts(mainPids, uid);
};

async function getMainPosts(mainPids, uid) {
    let postData = await posts.getPostsByPids(mainPids, uid);
    postData = await user.blocks.filter(uid, postData);
    postData.forEach((post) => {
        if (post) {
            post.index = 0;
        }
    });
    return await Topics.addPostData(postData, uid);
}

Topics.isLocked = async function (tid) {
    const locked = await Topics.getTopicField(tid, 'locked');
    return locked === 1;
};

Topics.search = async function (tid, term) {
    if (!tid || !term) {
        throw new Error('[[error:invalid-data]]');
    }
    const result = await plugins.hooks.fire('filter:topic.search', {
        tid: tid,
        term: term,
        ids: [],
    });
    return Array.isArray(result) ? result : result.ids;
};

require('../promisify')(Topics);

1	'use strict';
2
3	const _ = require('lodash');	20✔
4	const validator = require('validator');	20✔
5
6	const db = require('../database');	20✔
7	const posts = require('../posts');	20✔
8	const utils = require('../utils');	20✔
9	const plugins = require('../plugins');	20✔
10	const meta = require('../meta');	20✔
11	const user = require('../user');	20✔
12	const categories = require('../categories');	20✔
13	const privileges = require('../privileges');	20✔
14	const social = require('../social');	20✔
15
16	const Topics = module.exports;	20✔
17
18	require('./data')(Topics);	20✔
19	require('./create')(Topics);	20✔
20	require('./delete')(Topics);	20✔
21	require('./sorted')(Topics);	20✔
22	require('./unread')(Topics);	20✔
23	require('./recent')(Topics);	20✔
24	require('./user')(Topics);	20✔
25	require('./fork')(Topics);	20✔
26	require('./posts')(Topics);	20✔
27	require('./follow')(Topics);	20✔
28	require('./tags')(Topics);	20✔
29	require('./teaser')(Topics);	20✔
30	Topics.scheduled = require('./scheduled');	20✔
31	require('./suggested')(Topics);	20✔
32	require('./tools')(Topics);	20✔
33	Topics.thumbs = require('./thumbs');	20✔
34	require('./bookmarks')(Topics);	20✔
35	require('./merge')(Topics);	20✔
36	Topics.events = require('./events');	20✔
37
38	Topics.exists = async function (tids) {	20✔
39	return await db.exists(	2,348✔
40	Array.isArray(tids) ? tids.map(tid => `topic:${tid}`) : `topic:${tids}`	112✔
41	);
42	};
43
44	Topics.getTopicsFromSet = async function (set, uid, start, stop) {	20✔
45	const tids = await db.getSortedSetRevRange(set, start, stop);	24✔
46	const topics = await Topics.getTopics(tids, uid);	24✔
47	Topics.calculateTopicIndices(topics, start);	24✔
48	return { topics: topics, nextStart: stop + 1 };	24✔
49	};
50
51	Topics.getTopics = async function (tids, options) {	20✔
52	let uid = options;	40✔
53	if (typeof options === 'object') {	40✔
54	uid = options.uid;	4✔
55	}
56
57	tids = await privileges.topics.filterTids('topics:read', tids, uid);	40✔
58	return await Topics.getTopicsByTids(tids, options);	40✔
59	};
60
61	Topics.getTopicsByTids = async function (tids, options) {	20✔
62	if (!Array.isArray(tids) \|\| !tids.length) {	928✔
63	return [];	56✔
64	}
65	let uid = options;	872✔
66	if (typeof options === 'object') {	872✔
67	uid = options.uid;	72✔
68	}
69
70	async function loadTopics() {
71	const topics = await Topics.getTopicsData(tids);	872✔
72	const uids = _.uniq(topics.map(t => t && t.uid && t.uid.toString()).filter(v => utils.isNumber(v)));	1,306✔
73	const cids = _.uniq(topics.map(t => t && t.cid && t.cid.toString()).filter(v => utils.isNumber(v)));	1,306✔
74	const guestTopics = topics.filter(t => t && t.uid === 0);	1,306✔
75
76	async function loadGuestHandles() {
77	const mainPids = guestTopics.map(t => t.mainPid);	872✔
78	const postData = await posts.getPostsFields(mainPids, ['handle']);	872✔
79	return postData.map(p => p.handle);	872✔
80	}
81
82	async function loadShowfullnameSettings() {
83	if (meta.config.hideFullname) {	872✔
84	return uids.map(() => ({ showfullname: false }));	28✔
85	}
86	const data = await db.getObjectsFields(uids.map(uid => `user:${uid}:settings`), ['showfullname']);	933✔
87	data.forEach((settings) => {	864✔
88	settings.showfullname = parseInt(settings.showfullname, 10) === 1;	933✔
89	});
90	return data;	864✔
91	}
92
93	const [teasers, users, userSettings, categoriesData, guestHandles, thumbs] = await Promise.all([	872✔
94	Topics.getTeasers(topics, options),
95	user.getUsersFields(uids, ['uid', 'username', 'fullname', 'userslug', 'reputation', 'postcount', 'picture', 'signature', 'banned', 'status']),
96	loadShowfullnameSettings(),
97	categories.getCategoriesFields(cids, ['cid', 'name', 'slug', 'icon', 'backgroundImage', 'imageClass', 'bgColor', 'color', 'disabled']),
98	loadGuestHandles(),
99	Topics.thumbs.load(topics),
100	]);
101
102	users.forEach((userObj, idx) => {	872✔
103	// Hide fullname if needed
104	if (!userSettings[idx].showfullname) {	961✔
105	userObj.fullname = undefined;	957✔
106	}
107	});
108
109	return {	872✔
110	topics,
111	teasers,
112	usersMap: _.zipObject(uids, users),
113	categoriesMap: _.zipObject(cids, categoriesData),
114	tidToGuestHandle: _.zipObject(guestTopics.map(t => t.tid), guestHandles),	40✔
115	thumbs,
116	};
117	}
118
119	const [result, hasRead, isIgnored, bookmarks, callerSettings] = await Promise.all([	872✔
120	loadTopics(),
121	Topics.hasReadTopics(tids, uid),
122	Topics.isIgnoring(tids, uid),
123	Topics.getUserBookmarks(tids, uid),
124	user.getSettings(uid),
125	]);
126
127	const sortNewToOld = callerSettings.topicPostSort === 'newest_to_oldest';	872✔
128	result.topics.forEach((topic, i) => {	872✔
129	if (topic) {	1,306!
130	topic.thumbs = result.thumbs[i];	1,306✔
131	topic.category = result.categoriesMap[topic.cid];	1,306✔
132	topic.user = topic.uid ? result.usersMap[topic.uid] : { ...result.usersMap[topic.uid] };	1,306✔
133	if (result.tidToGuestHandle[topic.tid]) {	1,306✔
134	topic.user.username = validator.escape(result.tidToGuestHandle[topic.tid]);	20✔
135	topic.user.displayname = topic.user.username;	20✔
136	}
137	topic.teaser = result.teasers[i] \|\| null;	1,306✔
138	topic.isOwner = topic.uid === parseInt(uid, 10);	1,306✔
139	topic.ignored = isIgnored[i];	1,306✔
140	topic.unread = parseInt(uid, 10) <= 0 \|\| (!hasRead[i] && !isIgnored[i]);	1,306✔
141	topic.bookmark = sortNewToOld ?	1,306!
142	Math.max(1, topic.postcount + 2 - bookmarks[i]) :
143	Math.min(topic.postcount, bookmarks[i] + 1);
144	topic.unreplied = !topic.teaser;	1,306✔
145
146	topic.icons = [];	1,306✔
147	}
148	});
149
150	const filteredTopics = result.topics.filter(topic => topic && topic.category && !topic.category.disabled);	1,306✔
151
152	const hookResult = await plugins.hooks.fire('filter:topics.get', { topics: filteredTopics, uid: uid });	872✔
153	return hookResult.topics;	872✔
154	};
155
156	Topics.getTopicWithPosts = async function (topicData, set, uid, start, stop, reverse) {	20✔
157	const [
158	posts,
159	category,
160	tagWhitelist,
161	threadTools,
162	followData,
163	bookmark,
164	postSharing,
165	deleter,
166	merger,
167	related,
168	thumbs,
169	events,
170	] = await Promise.all([	112✔
171	Topics.getTopicPosts(topicData, set, start, stop, uid, reverse),
172	categories.getCategoryData(topicData.cid),
173	categories.getTagWhitelist([topicData.cid]),
174	plugins.hooks.fire('filter:topic.thread_tools', { topic: topicData, uid: uid, tools: [] }),
175	Topics.getFollowData([topicData.tid], uid),
176	Topics.getUserBookmark(topicData.tid, uid),
177	social.getActivePostSharing(),
178	getDeleter(topicData),
179	getMerger(topicData),
180	Topics.getRelatedTopics(topicData, uid),
181	Topics.thumbs.load([topicData]),
182	Topics.events.get(topicData.tid, uid, reverse),
183	]);
184
185	topicData.thumbs = thumbs[0];	112✔
186	topicData.posts = posts;	112✔
187	topicData.events = events;	112✔
188	topicData.posts.forEach((p) => {	112✔
189	p.events = events.filter(	540✔
190	event => event.timestamp >= p.eventStart && event.timestamp < p.eventEnd	×
191	);
192	});
193
194	topicData.category = category;	112✔
195	topicData.tagWhitelist = tagWhitelist[0];	112✔
196	topicData.minTags = category.minTags;	112✔
197	topicData.maxTags = category.maxTags;	112✔
198	topicData.thread_tools = threadTools.tools;	112✔
199	topicData.isFollowing = followData[0].following;	112✔
200	topicData.isNotFollowing = !followData[0].following && !followData[0].ignoring;	112✔
201	topicData.isIgnoring = followData[0].ignoring;	112✔
202	topicData.bookmark = bookmark;	112✔
203	topicData.postSharing = postSharing;	112✔
204	topicData.deleter = deleter;	112✔
205	if (deleter) {	112✔
206	topicData.deletedTimestampISO = utils.toISOString(topicData.deletedTimestamp);	20✔
207	}
208	topicData.merger = merger;	112✔
209	if (merger) {	112✔
210	topicData.mergedTimestampISO = utils.toISOString(topicData.mergedTimestamp);	20✔
211	}
212
213	if (topicData.isAnonymous === 'true') {	112!
NEW 214	topicData.user = {	×
215	username: 'anon',
216	displayname: 'anon',
217	isAnonymous: topicData.isAnonymous,
218	};
NEW 219	topicData.uid = -1;	×
220	}
221	// If isAnonymous it sets the user property to an anonymous user object with a username and display name of 'anon',
222	// and it also sets the uid property to -1 to indicate that this is an anonymous user.
223
224
225	topicData.related = related \|\| [];	112!
226	topicData.unreplied = topicData.postcount === 1;	112✔
227	topicData.icons = [];	112✔
228
229	const result = await plugins.hooks.fire('filter:topic.get', { topic: topicData, uid: uid });	112✔
230	return result.topic;	112✔
231	};
232
233	async function getDeleter(topicData) {
234	if (!parseInt(topicData.deleterUid, 10)) {	112✔
235	return null;	92✔
236	}
237	return await user.getUserFields(topicData.deleterUid, ['username', 'userslug', 'picture']);	20✔
238	}
239
240	async function getMerger(topicData) {
241	if (!parseInt(topicData.mergerUid, 10)) {	112✔
242	return null;	92✔
243	}
244	const [
245	merger,
246	mergedIntoTitle,
247	] = await Promise.all([	20✔
248	user.getUserFields(topicData.mergerUid, ['username', 'userslug', 'picture']),
249	Topics.getTopicField(topicData.mergeIntoTid, 'title'),
250	]);
251	merger.mergedIntoTitle = mergedIntoTitle;	20✔
252	return merger;	20✔
253	}
254
255	Topics.getMainPost = async function (tid, uid) {	20✔
256	const mainPosts = await Topics.getMainPosts([tid], uid);	36✔
257	return Array.isArray(mainPosts) && mainPosts.length ? mainPosts[0] : null;	36!
258	};
259
260	Topics.getMainPids = async function (tids) {	20✔
261	if (!Array.isArray(tids) \|\| !tids.length) {	180✔
262	return [];	17✔
263	}
264	const topicData = await Topics.getTopicsFields(tids, ['mainPid']);	163✔
265	return topicData.map(topic => topic && topic.mainPid);	355✔
266	};
267
268	Topics.getMainPosts = async function (tids, uid) {	20✔
269	const mainPids = await Topics.getMainPids(tids);	36✔
270	return await getMainPosts(mainPids, uid);	36✔
271	};
272
273	async function getMainPosts(mainPids, uid) {
274	let postData = await posts.getPostsByPids(mainPids, uid);	36✔
275	postData = await user.blocks.filter(uid, postData);	36✔
276	postData.forEach((post) => {	36✔
277	if (post) {	36!
278	post.index = 0;	36✔
279	}
280	});
281	return await Topics.addPostData(postData, uid);	36✔
282	}
283
284	Topics.isLocked = async function (tid) {	20✔
285	const locked = await Topics.getTopicField(tid, 'locked');	124✔
286	return locked === 1;	124✔
287	};
288
289	Topics.search = async function (tid, term) {	20✔
290	if (!tid \|\| !term) {	8✔
291	throw new Error('[[error:invalid-data]]');	4✔
292	}
293	const result = await plugins.hooks.fire('filter:topic.search', {	4✔
294	tid: tid,
295	term: term,
296	ids: [],
297	});
298	return Array.isArray(result) ? result : result.ids;	4!
299	};
300
301	require('../promisify')(Topics);	20✔

CMU-17313Q / fall23-nodebb-generation-z / 6290725310

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