6224432958

Committed 18 Sep 2023 03:08PM UTC coverage: 84.948% (-0.02%) from 84.965%

Build # 6224432958

Build Type

Pull #11

github

Committed by

web-flow

Commit Message

Merge 6f40091a0 into c90d36662

Pull Request Pull Request #11: added isanonymous attribute to support anon posts. Resolves #7

Run Details

10214 of 13265 branches covered (0.0%)

Branch coverage included in aggregate %.

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

1 existing line in 1 file now uncovered.

22603 of 25367 relevant lines covered (89.1%)

3126.65 hits per line

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

87.41

/src/topics/posts.js


'use strict';

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

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

const backlinkRegex = new RegExp(`(?:${nconf.get('url').replace('/', '\\/')}|\b|\\s)\\/topic\\/(\\d+)(?:\\/\\w+)?`, 'g');

module.exports = function (Topics) {
    Topics.onNewPostMade = async function (postData) {
        await Topics.updateLastPostTime(postData.tid, postData.timestamp);
        await Topics.addPostToTopic(postData.tid, postData);
    };

    Topics.getTopicPosts = async function (topicData, set, start, stop, uid, reverse) {
        if (!topicData) {
            return [];
        }

        let repliesStart = start;
        let repliesStop = stop;
        if (stop > 0) {
            repliesStop -= 1;
            if (start > 0) {
                repliesStart -= 1;
            }
        }
        let pids = [];
        if (start !== 0 || stop !== 0) {
            pids = await posts.getPidsFromSet(set, repliesStart, repliesStop, reverse);
        }
        if (!pids.length && !topicData.mainPid) {
            return [];
        }

        if (topicData.mainPid && start === 0) {
            pids.unshift(topicData.mainPid);
        }
        let postData = await posts.getPostsByPids(pids, uid);
        if (!postData.length) {
            return [];
        }
        let replies = postData;
        if (topicData.mainPid && start === 0) {
            postData[0].index = 0;
            replies = postData.slice(1);
        }

        Topics.calculatePostIndices(replies, repliesStart);
        await addEventStartEnd(postData, set, reverse, topicData);
        const allPosts = postData.slice();
        postData = await user.blocks.filter(uid, postData);
        if (allPosts.length !== postData.length) {
            const includedPids = new Set(postData.map(p => p.pid));
            allPosts.reverse().forEach((p, index) => {
                if (!includedPids.has(p.pid) && allPosts[index + 1] && !reverse) {
                    allPosts[index + 1].eventEnd = p.eventEnd;
                }
            });
        }

        const result = await plugins.hooks.fire('filter:topic.getPosts', {
            topic: topicData,
            uid: uid,
            posts: await Topics.addPostData(postData, uid),
        });
        return result.posts;
    };

    async function addEventStartEnd(postData, set, reverse, topicData) {
        if (!postData.length) {
            return;
        }
        postData.forEach((p, index) => {
            if (p && p.index === 0 && reverse) {
                p.eventStart = topicData.lastposttime;
                p.eventEnd = Date.now();
            } else if (p && postData[index + 1]) {
                p.eventStart = reverse ? postData[index + 1].timestamp : p.timestamp;
                p.eventEnd = reverse ? p.timestamp : postData[index + 1].timestamp;
            }
        });
        const lastPost = postData[postData.length - 1];
        if (lastPost) {
            lastPost.eventStart = reverse ? topicData.timestamp : lastPost.timestamp;
            lastPost.eventEnd = reverse ? lastPost.timestamp : Date.now();
            if (lastPost.index) {
                const nextPost = await db[reverse ? 'getSortedSetRevRangeWithScores' : 'getSortedSetRangeWithScores'](set, lastPost.index, lastPost.index);
                if (reverse) {
                    lastPost.eventStart = nextPost.length ? nextPost[0].score : lastPost.eventStart;
                } else {
                    lastPost.eventEnd = nextPost.length ? nextPost[0].score : lastPost.eventEnd;
                }
            }
        }
    }

    Topics.addPostData = async function (postData, uid) {
        if (!Array.isArray(postData) || !postData.length) {
            return [];
        }
        const pids = postData.map(post => post && post.pid);

        async function getPostUserData(field, method) {
            const uids = _.uniq(postData.filter(p => p && parseInt(p[field], 10) >= 0).map(p => p[field]));
            const userData = await method(uids);
            return _.zipObject(uids, userData);
        }
        const [
            bookmarks,
            voteData,
            userData,
            editors,
            replies,
        ] = await Promise.all([
            posts.hasBookmarked(pids, uid),
            posts.getVoteStatusByPostIDs(pids, uid),
            getPostUserData('uid', async uids => await posts.getUserInfoForPosts(uids, uid)),
            getPostUserData('editor', async uids => await user.getUsersFields(uids, ['uid', 'username', 'userslug'])),
            getPostReplies(pids, uid),
            Topics.addParentPosts(postData),
        ]);

        postData.forEach((postObj, i) => {
            if (postObj) {
                postObj.user = postObj.uid ? userData[postObj.uid] : { ...userData[postObj.uid] };
                postObj.editor = postObj.editor ? editors[postObj.editor] : null;
                postObj.bookmarked = bookmarks[i];
                postObj.upvoted = voteData.upvotes[i];
                postObj.downvoted = voteData.downvotes[i];
                postObj.votes = postObj.votes || 0;
                postObj.replies = replies[i];
                postObj.selfPost = parseInt(uid, 10) > 0 && parseInt(uid, 10) === postObj.uid;

                // Username override for guests, if enabled
                if (meta.config.allowGuestHandles && postObj.uid === 0 && postObj.handle) {
                    postObj.user.username = validator.escape(String(postObj.handle));
                    postObj.user.displayname = postObj.user.username;
                }
                if (postObj.selfPost === false && postObj.isAnonymous === 'true') {
                    postObj.user = {
                        username: 'anon',
                        displayname: 'anon',
                        isAnonymous: postObj.isAnonymous,
                    };
                    postObj.uid = -1;
                }
            }
        });

        const result = await plugins.hooks.fire('filter:topics.addPostData', {
            posts: postData,
            uid: uid,
        });
        return result.posts;
    };

    Topics.modifyPostsByPrivilege = function (topicData, topicPrivileges) {
        const loggedIn = parseInt(topicPrivileges.uid, 10) > 0;
        topicData.posts.forEach((post) => {
            if (post) {
                post.topicOwnerPost = parseInt(topicData.uid, 10) === parseInt(post.uid, 10);
                post.display_edit_tools = topicPrivileges.isAdminOrMod || (post.selfPost && topicPrivileges['posts:edit']);
                post.display_delete_tools = topicPrivileges.isAdminOrMod || (post.selfPost && topicPrivileges['posts:delete']);
                post.display_moderator_tools = post.display_edit_tools || post.display_delete_tools;
                post.display_move_tools = topicPrivileges.isAdminOrMod && post.index !== 0;
                post.display_post_menu = topicPrivileges.isAdminOrMod ||
                    (post.selfPost &&
                        ((!topicData.locked && !post.deleted) ||
                        (post.deleted && parseInt(post.deleterUid, 10) === parseInt(topicPrivileges.uid, 10)))) ||
                    ((loggedIn || topicData.postSharing.length) && !post.deleted);
                post.ip = topicPrivileges.isAdminOrMod ? post.ip : undefined;

                posts.modifyPostByPrivilege(post, topicPrivileges);
            }
        });
    };

    Topics.addParentPosts = async function (postData) {
        let parentPids = postData.map(postObj => (postObj && postObj.hasOwnProperty('toPid') ? parseInt(postObj.toPid, 10) : null)).filter(Boolean);

        if (!parentPids.length) {
            return;
        }
        parentPids = _.uniq(parentPids);
        const parentPosts = await posts.getPostsFields(parentPids, ['uid']);
        const parentUids = _.uniq(parentPosts.map(postObj => postObj && postObj.uid));
        const userData = await user.getUsersFields(parentUids, ['username']);

        const usersMap = {};
        userData.forEach((user) => {
            usersMap[user.uid] = user.username;
        });
        const parents = {};
        parentPosts.forEach((post, i) => {
            parents[parentPids[i]] = { username: usersMap[post.uid] };
        });

        postData.forEach((post) => {
            post.parent = parents[post.toPid];
        });
    };

    Topics.calculatePostIndices = function (posts, start) {
        posts.forEach((post, index) => {
            if (post) {
                post.index = start + index + 1;
            }
        });
    };

    Topics.getLatestUndeletedPid = async function (tid) {
        const pid = await Topics.getLatestUndeletedReply(tid);
        if (pid) {
            return pid;
        }
        const mainPid = await Topics.getTopicField(tid, 'mainPid');
        const mainPost = await posts.getPostFields(mainPid, ['pid', 'deleted']);
        return mainPost.pid && !mainPost.deleted ? mainPost.pid : null;
    };

    Topics.getLatestUndeletedReply = async function (tid) {
        let isDeleted = false;
        let index = 0;
        do {
            /* eslint-disable no-await-in-loop */
            const pids = await db.getSortedSetRevRange(`tid:${tid}:posts`, index, index);
            if (!pids.length) {
                return null;
            }
            isDeleted = await posts.getPostField(pids[0], 'deleted');
            if (!isDeleted) {
                return parseInt(pids[0], 10);
            }
            index += 1;
        } while (isDeleted);
    };

    Topics.addPostToTopic = async function (tid, postData) {
        const mainPid = await Topics.getTopicField(tid, 'mainPid');
        if (!parseInt(mainPid, 10)) {
            await Topics.setTopicField(tid, 'mainPid', postData.pid);
        } else {
            const upvotes = parseInt(postData.upvotes, 10) || 0;
            const downvotes = parseInt(postData.downvotes, 10) || 0;
            const votes = upvotes - downvotes;
            await db.sortedSetsAdd([
                `tid:${tid}:posts`, `tid:${tid}:posts:votes`,
            ], [postData.timestamp, votes], postData.pid);
        }
        await Topics.increasePostCount(tid);
        await db.sortedSetIncrBy(`tid:${tid}:posters`, 1, postData.uid);
        const posterCount = await db.sortedSetCard(`tid:${tid}:posters`);
        await Topics.setTopicField(tid, 'postercount', posterCount);
        await Topics.updateTeaser(tid);
    };

    Topics.removePostFromTopic = async function (tid, postData) {
        await db.sortedSetsRemove([
            `tid:${tid}:posts`,
            `tid:${tid}:posts:votes`,
        ], postData.pid);
        await Topics.decreasePostCount(tid);
        await db.sortedSetIncrBy(`tid:${tid}:posters`, -1, postData.uid);
        await db.sortedSetsRemoveRangeByScore([`tid:${tid}:posters`], '-inf', 0);
        const posterCount = await db.sortedSetCard(`tid:${tid}:posters`);
        await Topics.setTopicField(tid, 'postercount', posterCount);
        await Topics.updateTeaser(tid);
    };

    Topics.getPids = async function (tid) {
        let [mainPid, pids] = await Promise.all([
            Topics.getTopicField(tid, 'mainPid'),
            db.getSortedSetRange(`tid:${tid}:posts`, 0, -1),
        ]);
        if (parseInt(mainPid, 10)) {
            pids = [mainPid].concat(pids);
        }
        return pids;
    };

    Topics.increasePostCount = async function (tid) {
        incrementFieldAndUpdateSortedSet(tid, 'postcount', 1, 'topics:posts');
    };

    Topics.decreasePostCount = async function (tid) {
        incrementFieldAndUpdateSortedSet(tid, 'postcount', -1, 'topics:posts');
    };

    Topics.increaseViewCount = async function (tid) {
        const cid = await Topics.getTopicField(tid, 'cid');
        incrementFieldAndUpdateSortedSet(tid, 'viewcount', 1, ['topics:views', `cid:${cid}:tids:views`]);
    };

    async function incrementFieldAndUpdateSortedSet(tid, field, by, set) {
        const value = await db.incrObjectFieldBy(`topic:${tid}`, field, by);
        await db[Array.isArray(set) ? 'sortedSetsAdd' : 'sortedSetAdd'](set, value, tid);
    }

    Topics.getTitleByPid = async function (pid) {
        return await Topics.getTopicFieldByPid('title', pid);
    };

    Topics.getTopicFieldByPid = async function (field, pid) {
        const tid = await posts.getPostField(pid, 'tid');
        return await Topics.getTopicField(tid, field);
    };

    Topics.getTopicDataByPid = async function (pid) {
        const tid = await posts.getPostField(pid, 'tid');
        return await Topics.getTopicData(tid);
    };

    Topics.getPostCount = async function (tid) {
        return await db.getObjectField(`topic:${tid}`, 'postcount');
    };

    async function getPostReplies(pids, callerUid) {
        const keys = pids.map(pid => `pid:${pid}:replies`);
        const arrayOfReplyPids = await db.getSortedSetsMembers(keys);

        const uniquePids = _.uniq(_.flatten(arrayOfReplyPids));

        let replyData = await posts.getPostsFields(uniquePids, ['pid', 'uid', 'isAnonymous', 'timestamp']);
        const result = await plugins.hooks.fire('filter:topics.getPostReplies', {
            uid: callerUid,
            replies: replyData,
        });
        replyData = await user.blocks.filter(callerUid, result.replies);

        const uids = replyData.map(replyData => replyData && replyData.uid);

        const uniqueUids = _.uniq(uids);

        const userData = await user.getUsersWithFields(uniqueUids, ['uid', 'username', 'userslug', 'picture'], callerUid);

        const uidMap = _.zipObject(uniqueUids, userData);
        const pidMap = _.zipObject(replyData.map(r => r.pid), replyData);

        const returnData = arrayOfReplyPids.map((replyPids) => {
            replyPids = replyPids.filter(pid => pidMap[pid]);
            const uidsUsed = {};
            const currentData = {
                hasMore: false,
                users: [],
                text: replyPids.length > 1 ? `[[topic:replies_to_this_post, ${replyPids.length}]]` : '[[topic:one_reply_to_this_post]]',
                count: replyPids.length,
                timestampISO: replyPids.length ? utils.toISOString(pidMap[replyPids[0]].timestamp) : undefined,
            };

            replyPids.sort((a, b) => parseInt(a, 10) - parseInt(b, 10));

            replyPids.forEach((replyPid) => {
                const replyData = pidMap[replyPid];
                if (!uidsUsed[replyData.uid] && currentData.users.length < 6) {
                    if (replyData.isAnonymous !== 'true') {
                        currentData.users.push(uidMap[replyData.uid]);
                        uidsUsed[replyData.uid] = true;
                    }
                }
            });

            if (currentData.users.length > 5) {
                currentData.users.pop();
                currentData.hasMore = true;
            }

            return currentData;
        });

        return returnData;
    }

    Topics.syncBacklinks = async (postData) => {
        if (!postData) {
            throw new Error('[[error:invalid-data]]');
        }

        // Scan post content for topic links
        const matches = [...postData.content.matchAll(backlinkRegex)];
        if (!matches) {
            return 0;
        }

        const { pid, uid, tid } = postData;
        let add = _.uniq(matches.map(match => match[1]).map(tid => parseInt(tid, 10)));

        const now = Date.now();
        const topicsExist = await Topics.exists(add);
        const current = (await db.getSortedSetMembers(`pid:${pid}:backlinks`)).map(tid => parseInt(tid, 10));
        const remove = current.filter(tid => !add.includes(tid));
        add = add.filter((_tid, idx) => topicsExist[idx] && !current.includes(_tid) && tid !== _tid);

        // Remove old backlinks
        await db.sortedSetRemove(`pid:${pid}:backlinks`, remove);

        // Add new backlinks
        await db.sortedSetAdd(`pid:${pid}:backlinks`, add.map(() => now), add);
        await Promise.all(add.map(async (tid) => {
            await Topics.events.log(tid, {
                uid,
                type: 'backlink',
                href: `/post/${pid}`,
            });
        }));

        return add.length + (current - remove);
    };
};

1
2	'use strict';
3
4	const _ = require('lodash');	20✔
5	const validator = require('validator');	20✔
6	const nconf = require('nconf');	20✔
7
8	const db = require('../database');	20✔
9	const user = require('../user');	20✔
10	const posts = require('../posts');	20✔
11	const meta = require('../meta');	20✔
12	const plugins = require('../plugins');	20✔
13	const utils = require('../utils');	20✔
14
15	const backlinkRegex = new RegExp(`(?:${nconf.get('url').replace('/', '\\/')}\|\b\|\\s)\\/topic\\/(\\d+)(?:\\/\\w+)?`, 'g');	20✔
16
17	module.exports = function (Topics) {	20✔
18	Topics.onNewPostMade = async function (postData) {	20✔
19	await Topics.updateLastPostTime(postData.tid, postData.timestamp);	1,048✔
20	await Topics.addPostToTopic(postData.tid, postData);	1,048✔
21	};
22
23	Topics.getTopicPosts = async function (topicData, set, start, stop, uid, reverse) {	20✔
24	if (!topicData) {	144✔
25	return [];	4✔
26	}
27
28	let repliesStart = start;	140✔
29	let repliesStop = stop;	140✔
30	if (stop > 0) {	140✔
31	repliesStop -= 1;	120✔
32	if (start > 0) {	120✔
33	repliesStart -= 1;	32✔
34	}
35	}
36	let pids = [];	140✔
37	if (start !== 0 \|\| stop !== 0) {	140✔
38	pids = await posts.getPidsFromSet(set, repliesStart, repliesStop, reverse);	136✔
39	}
40	if (!pids.length && !topicData.mainPid) {	140✔
41	return [];	20✔
42	}
43
44	if (topicData.mainPid && start === 0) {	120✔
45	pids.unshift(topicData.mainPid);	88✔
46	}
47	let postData = await posts.getPostsByPids(pids, uid);	120✔
48	if (!postData.length) {	120✔
49	return [];	4✔
50	}
51	let replies = postData;	116✔
52	if (topicData.mainPid && start === 0) {	116✔
53	postData[0].index = 0;	88✔
54	replies = postData.slice(1);	88✔
55	}
56
57	Topics.calculatePostIndices(replies, repliesStart);	116✔
58	await addEventStartEnd(postData, set, reverse, topicData);	116✔
59	const allPosts = postData.slice();	116✔
60	postData = await user.blocks.filter(uid, postData);	116✔
61	if (allPosts.length !== postData.length) {	116!
62	const includedPids = new Set(postData.map(p => p.pid));	×
63	allPosts.reverse().forEach((p, index) => {	×
64	if (!includedPids.has(p.pid) && allPosts[index + 1] && !reverse) {	×
65	allPosts[index + 1].eventEnd = p.eventEnd;	×
66	}
67	});
68	}
69
70	const result = await plugins.hooks.fire('filter:topic.getPosts', {	116✔
71	topic: topicData,
72	uid: uid,
73	posts: await Topics.addPostData(postData, uid),
74	});
75	return result.posts;	116✔
76	};
77
78	async function addEventStartEnd(postData, set, reverse, topicData) {
79	if (!postData.length) {	116!
80	return;	×
81	}
82	postData.forEach((p, index) => {	116✔
83	if (p && p.index === 0 && reverse) {	808✔
84	p.eventStart = topicData.lastposttime;	12✔
85	p.eventEnd = Date.now();	12✔
86	} else if (p && postData[index + 1]) {	796✔
87	p.eventStart = reverse ? postData[index + 1].timestamp : p.timestamp;	684✔
88	p.eventEnd = reverse ? p.timestamp : postData[index + 1].timestamp;	684✔
89	}
90	});
91	const lastPost = postData[postData.length - 1];	116✔
92	if (lastPost) {	116!
93	lastPost.eventStart = reverse ? topicData.timestamp : lastPost.timestamp;	116✔
94	lastPost.eventEnd = reverse ? lastPost.timestamp : Date.now();	116✔
95	if (lastPost.index) {	116✔
96	const nextPost = await db[reverse ? 'getSortedSetRevRangeWithScores' : 'getSortedSetRangeWithScores'](set, lastPost.index, lastPost.index);	76✔
97	if (reverse) {	76✔
98	lastPost.eventStart = nextPost.length ? nextPost[0].score : lastPost.eventStart;	20✔
99	} else {
100	lastPost.eventEnd = nextPost.length ? nextPost[0].score : lastPost.eventEnd;	56✔
101	}
102	}
103	}
104	}
105
106	Topics.addPostData = async function (postData, uid) {	20✔
107	if (!Array.isArray(postData) \|\| !postData.length) {	348✔
108	return [];	4✔
109	}
110	const pids = postData.map(post => post && post.pid);	1,036✔
111
112	async function getPostUserData(field, method) {
113	const uids = _.uniq(postData.filter(p => p && parseInt(p[field], 10) >= 0).map(p => p[field]));	2,072✔
114	const userData = await method(uids);	688✔
115	return _.zipObject(uids, userData);	688✔
116	}
117	const [
118	bookmarks,
119	voteData,
120	userData,
121	editors,
122	replies,
123	] = await Promise.all([	344✔
124	posts.hasBookmarked(pids, uid),
125	posts.getVoteStatusByPostIDs(pids, uid),
126	getPostUserData('uid', async uids => await posts.getUserInfoForPosts(uids, uid)),	344✔
127	getPostUserData('editor', async uids => await user.getUsersFields(uids, ['uid', 'username', 'userslug'])),	344✔
128	getPostReplies(pids, uid),
129	Topics.addParentPosts(postData),
130	]);
131
132	postData.forEach((postObj, i) => {	344✔
133	if (postObj) {	1,036!
134	postObj.user = postObj.uid ? userData[postObj.uid] : { ...userData[postObj.uid] };	1,036✔
135	postObj.editor = postObj.editor ? editors[postObj.editor] : null;	1,036✔
136	postObj.bookmarked = bookmarks[i];	1,036✔
137	postObj.upvoted = voteData.upvotes[i];	1,036✔
138	postObj.downvoted = voteData.downvotes[i];	1,036✔
139	postObj.votes = postObj.votes \|\| 0;	1,036✔
140	postObj.replies = replies[i];	1,036✔
141	postObj.selfPost = parseInt(uid, 10) > 0 && parseInt(uid, 10) === postObj.uid;	1,036✔
142
143	// Username override for guests, if enabled
144	if (meta.config.allowGuestHandles && postObj.uid === 0 && postObj.handle) {	1,036!
145	postObj.user.username = validator.escape(String(postObj.handle));	×
146	postObj.user.displayname = postObj.user.username;	×
147	}
148	if (postObj.selfPost === false && postObj.isAnonymous === 'true') {	1,036!
NEW 149	postObj.user = {	×
150	username: 'anon',
151	displayname: 'anon',
152	isAnonymous: postObj.isAnonymous,
153	};
NEW 154	postObj.uid = -1;	×
155	}
156	}
157	});
158
159	const result = await plugins.hooks.fire('filter:topics.addPostData', {	344✔
160	posts: postData,
161	uid: uid,
162	});
163	return result.posts;	344✔
164	};
165
166	Topics.modifyPostsByPrivilege = function (topicData, topicPrivileges) {	20✔
167	const loggedIn = parseInt(topicPrivileges.uid, 10) > 0;	60✔
168	topicData.posts.forEach((post) => {	60✔
169	if (post) {	176!
170	post.topicOwnerPost = parseInt(topicData.uid, 10) === parseInt(post.uid, 10);	176✔
171	post.display_edit_tools = topicPrivileges.isAdminOrMod \|\| (post.selfPost && topicPrivileges['posts:edit']);	176!
172	post.display_delete_tools = topicPrivileges.isAdminOrMod \|\| (post.selfPost && topicPrivileges['posts:delete']);	176!
173	post.display_moderator_tools = post.display_edit_tools \|\| post.display_delete_tools;	176✔
174	post.display_move_tools = topicPrivileges.isAdminOrMod && post.index !== 0;	176✔
175	post.display_post_menu = topicPrivileges.isAdminOrMod \|\|	176!
176	(post.selfPost &&
177	((!topicData.locked && !post.deleted) \|\|
178	(post.deleted && parseInt(post.deleterUid, 10) === parseInt(topicPrivileges.uid, 10)))) \|\|
179	((loggedIn \|\| topicData.postSharing.length) && !post.deleted);
180	post.ip = topicPrivileges.isAdminOrMod ? post.ip : undefined;	176✔
181
182	posts.modifyPostByPrivilege(post, topicPrivileges);	176✔
183	}
184	});
185	};
186
187	Topics.addParentPosts = async function (postData) {	20✔
188	let parentPids = postData.map(postObj => (postObj && postObj.hasOwnProperty('toPid') ? parseInt(postObj.toPid, 10) : null)).filter(Boolean);	2,084✔
189
190	if (!parentPids.length) {	1,392✔
191	return;	1,376✔
192	}
193	parentPids = _.uniq(parentPids);	16✔
194	const parentPosts = await posts.getPostsFields(parentPids, ['uid']);	16✔
195	const parentUids = _.uniq(parentPosts.map(postObj => postObj && postObj.uid));	16✔
196	const userData = await user.getUsersFields(parentUids, ['username']);	16✔
197
198	const usersMap = {};	16✔
199	userData.forEach((user) => {	16✔
200	usersMap[user.uid] = user.username;	16✔
201	});
202	const parents = {};	16✔
203	parentPosts.forEach((post, i) => {	16✔
204	parents[parentPids[i]] = { username: usersMap[post.uid] };	16✔
205	});
206
207	postData.forEach((post) => {	16✔
208	post.parent = parents[post.toPid];	16✔
209	});
210	};
211
212	Topics.calculatePostIndices = function (posts, start) {	20✔
213	posts.forEach((post, index) => {	116✔
214	if (post) {	720!
215	post.index = start + index + 1;	720✔
216	}
217	});
218	};
219
220	Topics.getLatestUndeletedPid = async function (tid) {	20✔
221	const pid = await Topics.getLatestUndeletedReply(tid);	252✔
222	if (pid) {	252✔
223	return pid;	140✔
224	}
225	const mainPid = await Topics.getTopicField(tid, 'mainPid');	112✔
226	const mainPost = await posts.getPostFields(mainPid, ['pid', 'deleted']);	112✔
227	return mainPost.pid && !mainPost.deleted ? mainPost.pid : null;	112✔
228	};
229
230	Topics.getLatestUndeletedReply = async function (tid) {	20✔
231	let isDeleted = false;	1,540✔
232	let index = 0;	1,540✔
233	do {	1,540✔
234	/* eslint-disable no-await-in-loop */
235	const pids = await db.getSortedSetRevRange(`tid:${tid}:posts`, index, index);	1,548✔
236	if (!pids.length) {	1,548✔
237	return null;	904✔
238	}
239	isDeleted = await posts.getPostField(pids[0], 'deleted');	644✔
240	if (!isDeleted) {	644✔
241	return parseInt(pids[0], 10);	636✔
242	}
243	index += 1;	8✔
244	} while (isDeleted);
245	};
246
247	Topics.addPostToTopic = async function (tid, postData) {	20✔
248	const mainPid = await Topics.getTopicField(tid, 'mainPid');	1,120✔
249	if (!parseInt(mainPid, 10)) {	1,120✔
250	await Topics.setTopicField(tid, 'mainPid', postData.pid);	700✔
251	} else {
252	const upvotes = parseInt(postData.upvotes, 10) \|\| 0;	420✔
253	const downvotes = parseInt(postData.downvotes, 10) \|\| 0;	420✔
254	const votes = upvotes - downvotes;	420✔
255	await db.sortedSetsAdd([	420✔
256	`tid:${tid}:posts`, `tid:${tid}:posts:votes`,
257	], [postData.timestamp, votes], postData.pid);
258	}
259	await Topics.increasePostCount(tid);	1,120✔
260	await db.sortedSetIncrBy(`tid:${tid}:posters`, 1, postData.uid);	1,120✔
261	const posterCount = await db.sortedSetCard(`tid:${tid}:posters`);	1,120✔
262	await Topics.setTopicField(tid, 'postercount', posterCount);	1,120✔
263	await Topics.updateTeaser(tid);	1,120✔
264	};
265
266	Topics.removePostFromTopic = async function (tid, postData) {	20✔
267	await db.sortedSetsRemove([	72✔
268	`tid:${tid}:posts`,
269	`tid:${tid}:posts:votes`,
270	], postData.pid);
271	await Topics.decreasePostCount(tid);	72✔
272	await db.sortedSetIncrBy(`tid:${tid}:posters`, -1, postData.uid);	72✔
273	await db.sortedSetsRemoveRangeByScore([`tid:${tid}:posters`], '-inf', 0);	72✔
274	const posterCount = await db.sortedSetCard(`tid:${tid}:posters`);	72✔
275	await Topics.setTopicField(tid, 'postercount', posterCount);	72✔
276	await Topics.updateTeaser(tid);	72✔
277	};
278
279	Topics.getPids = async function (tid) {	20✔
280	let [mainPid, pids] = await Promise.all([	124✔
281	Topics.getTopicField(tid, 'mainPid'),
282	db.getSortedSetRange(`tid:${tid}:posts`, 0, -1),
283	]);
284	if (parseInt(mainPid, 10)) {	124✔
285	pids = [mainPid].concat(pids);	104✔
286	}
287	return pids;	124✔
288	};
289
290	Topics.increasePostCount = async function (tid) {	20✔
291	incrementFieldAndUpdateSortedSet(tid, 'postcount', 1, 'topics:posts');	1,120✔
292	};
293
294	Topics.decreasePostCount = async function (tid) {	20✔
295	incrementFieldAndUpdateSortedSet(tid, 'postcount', -1, 'topics:posts');	72✔
296	};
297
298	Topics.increaseViewCount = async function (tid) {	20✔
299	const cid = await Topics.getTopicField(tid, 'cid');	44✔
300	incrementFieldAndUpdateSortedSet(tid, 'viewcount', 1, ['topics:views', `cid:${cid}:tids:views`]);	44✔
301	};
302
303	async function incrementFieldAndUpdateSortedSet(tid, field, by, set) {
304	const value = await db.incrObjectFieldBy(`topic:${tid}`, field, by);	1,236✔
305	await db[Array.isArray(set) ? 'sortedSetsAdd' : 'sortedSetAdd'](set, value, tid);	1,236✔
306	}
307
308	Topics.getTitleByPid = async function (pid) {	20✔
309	return await Topics.getTopicFieldByPid('title', pid);	40✔
310	};
311
312	Topics.getTopicFieldByPid = async function (field, pid) {	20✔
313	const tid = await posts.getPostField(pid, 'tid');	40✔
314	return await Topics.getTopicField(tid, field);	40✔
315	};
316
317	Topics.getTopicDataByPid = async function (pid) {	20✔
318	const tid = await posts.getPostField(pid, 'tid');	4✔
319	return await Topics.getTopicData(tid);	4✔
320	};
321
322	Topics.getPostCount = async function (tid) {	20✔
323	return await db.getObjectField(`topic:${tid}`, 'postcount');	12✔
324	};
325
326	async function getPostReplies(pids, callerUid) {
327	const keys = pids.map(pid => `pid:${pid}:replies`);	1,036✔
328	const arrayOfReplyPids = await db.getSortedSetsMembers(keys);	344✔
329
330	const uniquePids = _.uniq(_.flatten(arrayOfReplyPids));	344✔
331
332	let replyData = await posts.getPostsFields(uniquePids, ['pid', 'uid', 'isAnonymous', 'timestamp']);	344✔
333	const result = await plugins.hooks.fire('filter:topics.getPostReplies', {	344✔
334	uid: callerUid,
335	replies: replyData,
336	});
337	replyData = await user.blocks.filter(callerUid, result.replies);	344✔
338
339	const uids = replyData.map(replyData => replyData && replyData.uid);	344!
340
341	const uniqueUids = _.uniq(uids);	344✔
342
343	const userData = await user.getUsersWithFields(uniqueUids, ['uid', 'username', 'userslug', 'picture'], callerUid);	344✔
344
345	const uidMap = _.zipObject(uniqueUids, userData);	344✔
346	const pidMap = _.zipObject(replyData.map(r => r.pid), replyData);	344✔
347
348	const returnData = arrayOfReplyPids.map((replyPids) => {	344✔
349	replyPids = replyPids.filter(pid => pidMap[pid]);	1,036✔
350	const uidsUsed = {};	1,036✔
351	const currentData = {	1,036✔
352	hasMore: false,
353	users: [],
354	text: replyPids.length > 1 ? `[[topic:replies_to_this_post, ${replyPids.length}]]` : '[[topic:one_reply_to_this_post]]',	1,036!
355	count: replyPids.length,
356	timestampISO: replyPids.length ? utils.toISOString(pidMap[replyPids[0]].timestamp) : undefined,	1,036!
357	};
358
359	replyPids.sort((a, b) => parseInt(a, 10) - parseInt(b, 10));	1,036✔
360
361	replyPids.forEach((replyPid) => {	1,036✔
362	const replyData = pidMap[replyPid];	×
363	if (!uidsUsed[replyData.uid] && currentData.users.length < 6) {	×
NEW 364	if (replyData.isAnonymous !== 'true') {	×
NEW 365	currentData.users.push(uidMap[replyData.uid]);	×
NEW 366	uidsUsed[replyData.uid] = true;	×
367	}
368	}
369	});
370
371	if (currentData.users.length > 5) {	1,036!
372	currentData.users.pop();	×
373	currentData.hasMore = true;	×
374	}
375
376	return currentData;	1,036✔
377	});
378
379	return returnData;	344✔
380	}
381
382	Topics.syncBacklinks = async (postData) => {	20✔
383	if (!postData) {	1,128✔
384	throw new Error('[[error:invalid-data]]');	4✔
385	}
386
387	// Scan post content for topic links
388	const matches = [...postData.content.matchAll(backlinkRegex)];	1,124✔
389	if (!matches) {	1,124!
390	return 0;	×
391	}
392
393	const { pid, uid, tid } = postData;	1,124✔
394	let add = _.uniq(matches.map(match => match[1]).map(tid => parseInt(tid, 10)));	1,124✔
395
396	const now = Date.now();	1,124✔
397	const topicsExist = await Topics.exists(add);	1,124✔
398	const current = (await db.getSortedSetMembers(`pid:${pid}:backlinks`)).map(tid => parseInt(tid, 10));	1,124✔
399	const remove = current.filter(tid => !add.includes(tid));	1,124✔
400	add = add.filter((_tid, idx) => topicsExist[idx] && !current.includes(_tid) && tid !== _tid);	1,124✔
401
402	// Remove old backlinks
403	await db.sortedSetRemove(`pid:${pid}:backlinks`, remove);	1,124✔
404
405	// Add new backlinks
406	await db.sortedSetAdd(`pid:${pid}:backlinks`, add.map(() => now), add);	1,124✔
407	await Promise.all(add.map(async (tid) => {	1,124✔
408	await Topics.events.log(tid, {	12✔
409	uid,
410	type: 'backlink',
411	href: `/post/${pid}`,
412	});
413	}));
414
415	return add.length + (current - remove);	1,124✔
416	};
417	};

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

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