6300344775

Committed 25 Sep 2023 01:58PM UTC coverage: 84.761% (+7.6%) from 77.199%

Build # 6300344775

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #70 from CMU-17313Q/Resolving-test-errors-from-sprint-1

Resolving test errors from sprint 1

Run Details

10231 of 13310 branches covered (0.0%)

Branch coverage included in aggregate %.

126 of 133 new or added lines in 1 file covered. (94.74%)

2 existing lines in 2 files now uncovered.

22608 of 25433 relevant lines covered (88.89%)

3241.54 hits per line

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

91.67

/src/topics/create.js


'use strict';

const _ = require('lodash');

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

module.exports = function (Topics) {
    Topics.create = async function (data) {
        // This is an internal method, consider using Topics.post instead
        const timestamp = data.timestamp || Date.now();

        const tid = await db.incrObjectField('global', 'nextTid');

        let topicData = {
            tid: tid,
            uid: data.uid,
            cid: data.cid,
            mainPid: 0,
            title: data.title,
            slug: `${tid}/${slugify(data.title) || 'topic'}`,
            timestamp: timestamp,
            lastposttime: 0,
            postcount: 0,
            viewcount: 0,
            isPrivate: false,
            isAnonymous: false,
        };
        topicData.isPrivate = data.isPrivate
        topicData.isAnonymous = data.isAnonymous

        if (Array.isArray(data.tags) && data.tags.length) {
            topicData.tags = data.tags.join(',');
        }

        const result = await plugins.hooks.fire('filter:topic.create', { topic: topicData, data: data });
        topicData = result.topic;
        await db.setObject(`topic:${topicData.tid}`, topicData);

        const timestampedSortedSetKeys = [
            'topics:tid',
            `cid:${topicData.cid}:tids`,
            `cid:${topicData.cid}:uid:${topicData.uid}:tids`,
        ];

        const scheduled = timestamp > Date.now();
        if (scheduled) {
            timestampedSortedSetKeys.push('topics:scheduled');
        }

        await Promise.all([
            db.sortedSetsAdd(timestampedSortedSetKeys, timestamp, topicData.tid),
            db.sortedSetsAdd([
                'topics:views', 'topics:posts', 'topics:votes',
                `cid:${topicData.cid}:tids:votes`,
                `cid:${topicData.cid}:tids:posts`,
                `cid:${topicData.cid}:tids:views`,
            ], 0, topicData.tid),
            user.addTopicIdToUser(topicData.uid, topicData.tid, timestamp),
            db.incrObjectField(`category:${topicData.cid}`, 'topic_count'),
            db.incrObjectField('global', 'topicCount'),
            Topics.createTags(data.tags, topicData.tid, timestamp),
            scheduled ? Promise.resolve() : categories.updateRecentTid(topicData.cid, topicData.tid),
        ]);
        if (scheduled) {
            await Topics.scheduled.pin(tid, topicData);
        }

        plugins.hooks.fire('action:topic.save', { topic: _.clone(topicData), data: data });
        return topicData.tid;
    };

    Topics.post = async function (data) {
        data = await plugins.hooks.fire('filter:topic.post', data);
        const { uid } = data;

        data.title = String(data.title).trim();
        data.tags = data.tags || [];
        if (data.content) {
            data.content = utils.rtrim(data.content);
        }
        Topics.checkTitle(data.title);
        await Topics.validateTags(data.tags, data.cid, uid);
        data.tags = await Topics.filterTags(data.tags, data.cid);
        if (!data.fromQueue) {
            Topics.checkContent(data.content);
        }

        const [categoryExists, canCreate, canTag] = await Promise.all([
            categories.exists(data.cid),
            privileges.categories.can('topics:create', data.cid, uid),
            privileges.categories.can('topics:tag', data.cid, uid),
        ]);

        if (!categoryExists) {
            throw new Error('[[error:no-category]]');
        }

        if (!canCreate || (!canTag && data.tags.length)) {
            throw new Error('[[error:no-privileges]]');
        }

        await guestHandleValid(data);
        if (!data.fromQueue) {
            await user.isReadyToPost(uid, data.cid);
        }

        const tid = await Topics.create(data);

        let postData = data;
        postData.tid = tid;
        postData.ip = data.req ? data.req.ip : null;
        postData.isMain = true;
        postData = await posts.create(postData);
        postData = await onNewPost(postData, data);

        const [settings, topics] = await Promise.all([
            user.getSettings(uid),
            Topics.getTopicsByTids([postData.tid], uid),
        ]);

        if (!Array.isArray(topics) || !topics.length) {
            throw new Error('[[error:no-topic]]');
        }

        if (uid > 0 && settings.followTopicsOnCreate) {
            await Topics.follow(postData.tid, uid);
        }
        const topicData = topics[0];
        topicData.unreplied = true;
        topicData.mainPost = postData;
        topicData.index = 0;
        postData.index = 0;

        if (topicData.scheduled) {
            await Topics.delete(tid);
        }

        analytics.increment(['topics', `topics:byCid:${topicData.cid}`]);
        plugins.hooks.fire('action:topic.post', { topic: topicData, post: postData, data: data });

        if (parseInt(uid, 10) && !topicData.scheduled) {
            user.notifications.sendTopicNotificationToFollowers(uid, topicData, postData);
        }

        return {
            topicData: topicData,
            postData: postData,
        };
    };

    Topics.reply = async function (data) {
        data = await plugins.hooks.fire('filter:topic.reply', data);
        const { tid } = data;
        const { uid } = data;

        const topicData = await Topics.getTopicData(tid);

        await canReply(data, topicData);

        data.cid = topicData.cid;

        await guestHandleValid(data);
        if (data.content) {
            data.content = utils.rtrim(data.content);
        }
        if (!data.fromQueue) {
            await user.isReadyToPost(uid, data.cid);
            Topics.checkContent(data.content);
        }

        // For replies to scheduled topics, don't have a timestamp older than topic's itself
        if (topicData.scheduled) {
            data.timestamp = topicData.lastposttime + 1;
        }

        data.ip = data.req ? data.req.ip : null;
        let postData = await posts.create(data);
        postData = await onNewPost(postData, data);

        const settings = await user.getSettings(uid);
        if (uid > 0 && settings.followTopicsOnReply) {
            await Topics.follow(postData.tid, uid);
        }

        if (parseInt(uid, 10)) {
            user.setUserField(uid, 'lastonline', Date.now());
        }

        if (parseInt(uid, 10) || meta.config.allowGuestReplyNotifications) {
            const { displayname } = postData.user;

            Topics.notifyFollowers(postData, uid, {
                type: 'new-reply',
                bodyShort: translator.compile('notifications:user_posted_to', displayname, postData.topic.title),
                nid: `new_post:tid:${postData.topic.tid}:pid:${postData.pid}:uid:${uid}`,
                mergeId: `notifications:user_posted_to|${postData.topic.tid}`,
            });
        }

        analytics.increment(['posts', `posts:byCid:${data.cid}`]);
        plugins.hooks.fire('action:topic.reply', { post: _.clone(postData), data: data });

        return postData;
    };

    async function onNewPost(postData, data) {
        const { tid } = postData;
        const { uid } = postData;
        await Topics.markAsUnreadForAll(tid);
        await Topics.markAsRead([tid], uid);
        const [
            userInfo,
            topicInfo,
        ] = await Promise.all([
            posts.getUserInfoForPosts([postData.uid], uid),
            Topics.getTopicFields(tid, ['tid', 'uid', 'title', 'slug', 'cid', 'postcount', 'mainPid', 'scheduled']),
            Topics.addParentPosts([postData]),
            Topics.syncBacklinks(postData),
            posts.parsePost(postData),
        ]);

        postData.user = userInfo[0];
        postData.topic = topicInfo;
        postData.index = topicInfo.postcount - 1;

        posts.overrideGuestHandle(postData, data.handle);

        postData.votes = 0;
        postData.bookmarked = false;
        postData.display_edit_tools = true;
        postData.display_delete_tools = true;
        postData.display_moderator_tools = true;
        postData.display_move_tools = true;
        postData.selfPost = false;
        postData.timestampISO = utils.toISOString(postData.timestamp);
        postData.topic.title = String(postData.topic.title);

        return postData;
    }

    Topics.checkTitle = function (title) {
        check(title, meta.config.minimumTitleLength, meta.config.maximumTitleLength, 'title-too-short', 'title-too-long');
    };

    Topics.checkContent = function (content) {
        check(content, meta.config.minimumPostLength, meta.config.maximumPostLength, 'content-too-short', 'content-too-long');
    };

    function check(item, min, max, minError, maxError) {
        // Trim and remove HTML (latter for composers that send in HTML, like redactor)
        if (typeof item === 'string') {
            item = utils.stripHTMLTags(item).trim();
        }

        if (item === null || item === undefined || item.length < parseInt(min, 10)) {
            throw new Error(`[[error:${minError}, ${min}]]`);
        } else if (item.length > parseInt(max, 10)) {
            throw new Error(`[[error:${maxError}, ${max}]]`);
        }
    }

    async function guestHandleValid(data) {
        if (meta.config.allowGuestHandles && parseInt(data.uid, 10) === 0 && data.handle) {
            if (data.handle.length > meta.config.maximumUsernameLength) {
                throw new Error('[[error:guest-handle-invalid]]');
            }
            const exists = await user.existsBySlug(slugify(data.handle));
            if (exists) {
                throw new Error('[[error:username-taken]]');
            }
        }
    }

    async function canReply(data, topicData) {
        if (!topicData) {
            throw new Error('[[error:no-topic]]');
        }
        const { tid, uid } = data;
        const { cid, deleted, locked, scheduled } = topicData;

        const [canReply, canSchedule, isAdminOrMod] = await Promise.all([
            privileges.topics.can('topics:reply', tid, uid),
            privileges.topics.can('topics:schedule', tid, uid),
            privileges.categories.isAdminOrMod(cid, uid),
        ]);

        if (locked && !isAdminOrMod) {
            throw new Error('[[error:topic-locked]]');
        }

        if (!scheduled && deleted && !isAdminOrMod) {
            throw new Error('[[error:topic-deleted]]');
        }

        if (scheduled && !canSchedule) {
            throw new Error('[[error:no-privileges]]');
        }

        if (!canReply) {
            throw new Error('[[error:no-privileges]]');
        }
    }
};

1
2	'use strict';
3
4	const _ = require('lodash');	20✔
5
6	const db = require('../database');	20✔
7	const utils = require('../utils');	20✔
8	const slugify = require('../slugify');	20✔
9	const plugins = require('../plugins');	20✔
10	const analytics = require('../analytics');	20✔
11	const user = require('../user');	20✔
12	const meta = require('../meta');	20✔
13	const posts = require('../posts');	20✔
14	const privileges = require('../privileges');	20✔
15	const categories = require('../categories');	20✔
16	const translator = require('../translator');	20✔
17
18	module.exports = function (Topics) {	20✔
19	Topics.create = async function (data) {	20✔
20	// This is an internal method, consider using Topics.post instead
21	const timestamp = data.timestamp \|\| Date.now();	692✔
22
23	const tid = await db.incrObjectField('global', 'nextTid');	692✔
24
25	let topicData = {	692✔
26	tid: tid,
27	uid: data.uid,
28	cid: data.cid,
29	mainPid: 0,
30	title: data.title,
31	slug: `${tid}/${slugify(data.title) \|\| 'topic'}`,	692!
32	timestamp: timestamp,
33	lastposttime: 0,
34	postcount: 0,
35	viewcount: 0,
36	isPrivate: false,
37	isAnonymous: false,
38	};
39	topicData.isPrivate = data.isPrivate	692✔
40	topicData.isAnonymous = data.isAnonymous	692✔
41
42	if (Array.isArray(data.tags) && data.tags.length) {	692✔
43	topicData.tags = data.tags.join(',');	108✔
44	}
45
46	const result = await plugins.hooks.fire('filter:topic.create', { topic: topicData, data: data });	692✔
47	topicData = result.topic;	692✔
48	await db.setObject(`topic:${topicData.tid}`, topicData);	692✔
49
50	const timestampedSortedSetKeys = [	692✔
51	'topics:tid',
52	`cid:${topicData.cid}:tids`,
53	`cid:${topicData.cid}:uid:${topicData.uid}:tids`,
54	];
55
56	const scheduled = timestamp > Date.now();	692✔
57	if (scheduled) {	692✔
58	timestampedSortedSetKeys.push('topics:scheduled');	8✔
59	}
60
61	await Promise.all([	692✔
62	db.sortedSetsAdd(timestampedSortedSetKeys, timestamp, topicData.tid),
63	db.sortedSetsAdd([
64	'topics:views', 'topics:posts', 'topics:votes',
65	`cid:${topicData.cid}:tids:votes`,
66	`cid:${topicData.cid}:tids:posts`,
67	`cid:${topicData.cid}:tids:views`,
68	], 0, topicData.tid),
69	user.addTopicIdToUser(topicData.uid, topicData.tid, timestamp),
70	db.incrObjectField(`category:${topicData.cid}`, 'topic_count'),
71	db.incrObjectField('global', 'topicCount'),
72	Topics.createTags(data.tags, topicData.tid, timestamp),
73	scheduled ? Promise.resolve() : categories.updateRecentTid(topicData.cid, topicData.tid),	692✔
74	]);
75	if (scheduled) {	692✔
76	await Topics.scheduled.pin(tid, topicData);	8✔
77	}
78
79	plugins.hooks.fire('action:topic.save', { topic: _.clone(topicData), data: data });	692✔
80	return topicData.tid;	692✔
81	};
82
83	Topics.post = async function (data) {	20✔
84	data = await plugins.hooks.fire('filter:topic.post', data);	732✔
85	const { uid } = data;	732✔
86
87	data.title = String(data.title).trim();	732✔
88	data.tags = data.tags \|\| [];	732✔
89	if (data.content) {	732✔
90	data.content = utils.rtrim(data.content);	728✔
91	}
92	Topics.checkTitle(data.title);	732✔
93	await Topics.validateTags(data.tags, data.cid, uid);	728✔
94	data.tags = await Topics.filterTags(data.tags, data.cid);	708✔
95	if (!data.fromQueue) {	708✔
96	Topics.checkContent(data.content);	704✔
97	}
98
99	const [categoryExists, canCreate, canTag] = await Promise.all([	704✔
100	categories.exists(data.cid),
101	privileges.categories.can('topics:create', data.cid, uid),
102	privileges.categories.can('topics:tag', data.cid, uid),
103	]);
104
105	if (!categoryExists) {	704✔
106	throw new Error('[[error:no-category]]');	4✔
107	}
108
109	if (!canCreate \|\| (!canTag && data.tags.length)) {	700✔
110	throw new Error('[[error:no-privileges]]');	16✔
111	}
112
113	await guestHandleValid(data);	684✔
114	if (!data.fromQueue) {	684✔
115	await user.isReadyToPost(uid, data.cid);	680✔
116	}
117
118	const tid = await Topics.create(data);	676✔
119
120	let postData = data;	676✔
121	postData.tid = tid;	676✔
122	postData.ip = data.req ? data.req.ip : null;	676✔
123	postData.isMain = true;	676✔
124	postData = await posts.create(postData);	676✔
125	postData = await onNewPost(postData, data);	676✔
126
127	const [settings, topics] = await Promise.all([	676✔
128	user.getSettings(uid),
129	Topics.getTopicsByTids([postData.tid], uid),
130	]);
131
132	if (!Array.isArray(topics) \|\| !topics.length) {	676!
NEW 133	throw new Error('[[error:no-topic]]');	×
134	}
135
136	if (uid > 0 && settings.followTopicsOnCreate) {	676✔
137	await Topics.follow(postData.tid, uid);	668✔
138	}
139	const topicData = topics[0];	676✔
140	topicData.unreplied = true;	676✔
141	topicData.mainPost = postData;	676✔
142	topicData.index = 0;	676✔
143	postData.index = 0;	676✔
144
145	if (topicData.scheduled) {	676✔
146	await Topics.delete(tid);	8✔
147	}
148
149	analytics.increment(['topics', `topics:byCid:${topicData.cid}`]);	676✔
150	plugins.hooks.fire('action:topic.post', { topic: topicData, post: postData, data: data });	676✔
151
152	if (parseInt(uid, 10) && !topicData.scheduled) {	676✔
153	user.notifications.sendTopicNotificationToFollowers(uid, topicData, postData);	660✔
154	}
155
156	return {	676✔
157	topicData: topicData,
158	postData: postData,
159	};
160	};
161
162	Topics.reply = async function (data) {	20✔
163	data = await plugins.hooks.fire('filter:topic.reply', data);	368✔
164	const { tid } = data;	368✔
165	const { uid } = data;	368✔
166
167	const topicData = await Topics.getTopicData(tid);	368✔
168
169	await canReply(data, topicData);	368✔
170
171	data.cid = topicData.cid;	360✔
172
173	await guestHandleValid(data);	360✔
174	if (data.content) {	360✔
175	data.content = utils.rtrim(data.content);	356✔
176	}
177	if (!data.fromQueue) {	360✔
178	await user.isReadyToPost(uid, data.cid);	356✔
179	Topics.checkContent(data.content);	356✔
180	}
181
182	// For replies to scheduled topics, don't have a timestamp older than topic's itself
183	if (topicData.scheduled) {	356✔
184	data.timestamp = topicData.lastposttime + 1;	4✔
185	}
186
187	data.ip = data.req ? data.req.ip : null;	356✔
188	let postData = await posts.create(data);	356✔
189	postData = await onNewPost(postData, data);	352✔
190
191	const settings = await user.getSettings(uid);	352✔
192	if (uid > 0 && settings.followTopicsOnReply) {	352!
NEW 193	await Topics.follow(postData.tid, uid);	×
194	}
195
196	if (parseInt(uid, 10)) {	352✔
197	user.setUserField(uid, 'lastonline', Date.now());	340✔
198	}
199
200	if (parseInt(uid, 10) \|\| meta.config.allowGuestReplyNotifications) {	352!
201	const { displayname } = postData.user;	352✔
202
203	Topics.notifyFollowers(postData, uid, {	352✔
204	type: 'new-reply',
205	bodyShort: translator.compile('notifications:user_posted_to', displayname, postData.topic.title),
206	nid: `new_post:tid:${postData.topic.tid}:pid:${postData.pid}:uid:${uid}`,
207	mergeId: `notifications:user_posted_to\|${postData.topic.tid}`,
208	});
209	}
210
211	analytics.increment(['posts', `posts:byCid:${data.cid}`]);	352✔
212	plugins.hooks.fire('action:topic.reply', { post: _.clone(postData), data: data });	352✔
213
214	return postData;	352✔
215	};
216
217	async function onNewPost(postData, data) {
218	const { tid } = postData;	1,028✔
219	const { uid } = postData;	1,028✔
220	await Topics.markAsUnreadForAll(tid);	1,028✔
221	await Topics.markAsRead([tid], uid);	1,028✔
222	const [
223	userInfo,
224	topicInfo,
225	] = await Promise.all([	1,028✔
226	posts.getUserInfoForPosts([postData.uid], uid),
227	Topics.getTopicFields(tid, ['tid', 'uid', 'title', 'slug', 'cid', 'postcount', 'mainPid', 'scheduled']),
228	Topics.addParentPosts([postData]),
229	Topics.syncBacklinks(postData),
230	posts.parsePost(postData),
231	]);
232
233	postData.user = userInfo[0];	1,028✔
234	postData.topic = topicInfo;	1,028✔
235	postData.index = topicInfo.postcount - 1;	1,028✔
236
237	posts.overrideGuestHandle(postData, data.handle);	1,028✔
238
239	postData.votes = 0;	1,028✔
240	postData.bookmarked = false;	1,028✔
241	postData.display_edit_tools = true;	1,028✔
242	postData.display_delete_tools = true;	1,028✔
243	postData.display_moderator_tools = true;	1,028✔
244	postData.display_move_tools = true;	1,028✔
245	postData.selfPost = false;	1,028✔
246	postData.timestampISO = utils.toISOString(postData.timestamp);	1,028✔
247	postData.topic.title = String(postData.topic.title);	1,028✔
248
249	return postData;	1,028✔
250	}
251
252	Topics.checkTitle = function (title) {	20✔
253	check(title, meta.config.minimumTitleLength, meta.config.maximumTitleLength, 'title-too-short', 'title-too-long');	736✔
254	};
255
256	Topics.checkContent = function (content) {	20✔
257	check(content, meta.config.minimumPostLength, meta.config.maximumPostLength, 'content-too-short', 'content-too-long');	1,072✔
258	};
259
260	function check(item, min, max, minError, maxError) {
261	// Trim and remove HTML (latter for composers that send in HTML, like redactor)
262	if (typeof item === 'string') {	1,808!
263	item = utils.stripHTMLTags(item).trim();	1,808✔
264	}
265
266	if (item === null \|\| item === undefined \|\| item.length < parseInt(min, 10)) {	1,808✔
267	throw new Error(`[[error:${minError}, ${min}]]`);	12✔
268	} else if (item.length > parseInt(max, 10)) {	1,796!
UNCOV 269	throw new Error(`[[error:${maxError}, ${max}]]`);	×
270	}
271	}
272
273	async function guestHandleValid(data) {
274	if (meta.config.allowGuestHandles && parseInt(data.uid, 10) === 0 && data.handle) {	1,044✔
275	if (data.handle.length > meta.config.maximumUsernameLength) {	8!
NEW 276	throw new Error('[[error:guest-handle-invalid]]');	×
277	}
278	const exists = await user.existsBySlug(slugify(data.handle));	8✔
279	if (exists) {	8!
NEW 280	throw new Error('[[error:username-taken]]');	×
281	}
282	}
283	}
284
285	async function canReply(data, topicData) {
286	if (!topicData) {	368✔
287	throw new Error('[[error:no-topic]]');	4✔
288	}
289	const { tid, uid } = data;	364✔
290	const { cid, deleted, locked, scheduled } = topicData;	364✔
291
292	const [canReply, canSchedule, isAdminOrMod] = await Promise.all([	364✔
293	privileges.topics.can('topics:reply', tid, uid),
294	privileges.topics.can('topics:schedule', tid, uid),
295	privileges.categories.isAdminOrMod(cid, uid),
296	]);
297
298	if (locked && !isAdminOrMod) {	364!
NEW 299	throw new Error('[[error:topic-locked]]');	×
300	}
301
302	if (!scheduled && deleted && !isAdminOrMod) {	364!
NEW 303	throw new Error('[[error:topic-deleted]]');	×
304	}
305
306	if (scheduled && !canSchedule) {	364!
NEW 307	throw new Error('[[error:no-privileges]]');	×
308	}
309
310	if (!canReply) {	364✔
311	throw new Error('[[error:no-privileges]]');	4✔
312	}
313	}
314	};

CMU-17313Q / fall23-nodebb-inshallah-a / 6300344775

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