6219038158

Committed 18 Sep 2023 06:34AM UTC coverage: 84.981% (+0.005%) from 84.976%

Build # 6219038158

Build Type

Pull #14

github

Committed by

web-flow

Commit Message

Merge 321f90b1e into f15cc7974

Pull Request Pull Request #14: Attempt 2 to add attribute "tag" to the post object, and create a dropdown in the front end to choose the type

Run Details

10212 of 13255 branches covered (0.0%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 2 files covered. (100.0%)

5 existing lines in 2 files now uncovered.

22600 of 25356 relevant lines covered (89.13%)

3127.55 hits per line

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

87.39

/src/user/approval.js

'use strict';

const validator = require('validator');
const winston = require('winston');
const cronJob = require('cron').CronJob;

const db = require('../database');
const meta = require('../meta');
const emailer = require('../emailer');
const notifications = require('../notifications');
const groups = require('../groups');
const utils = require('../utils');
const slugify = require('../slugify');
const plugins = require('../plugins');

module.exports = function (User) {
    new cronJob('0 * * * *', (() => {
        User.autoApprove();
    }), null, true);

    User.addToApprovalQueue = async function (userData) {
        userData.username = userData.username.trim();
        userData.userslug = slugify(userData.username);
        await canQueue(userData);
        const hashedPassword = await User.hashPassword(userData.password);
        const data = {
            username: userData.username,
            email: userData.email,
            ip: userData.ip,
            hashedPassword: hashedPassword,
        };
        const results = await plugins.hooks.fire('filter:user.addToApprovalQueue', { data: data, userData: userData });
        await db.setObject(`registration:queue:name:${userData.username}`, results.data);
        await db.sortedSetAdd('registration:queue', Date.now(), userData.username);
        await sendNotificationToAdmins(userData.username);
    };

    async function canQueue(userData) {
        await User.isDataValid(userData);
        const usernames = await db.getSortedSetRange('registration:queue', 0, -1);
        if (usernames.includes(userData.username)) {
            throw new Error('[[error:username-taken]]');
        }
        const keys = usernames.filter(Boolean).map(username => `registration:queue:name:${username}`);
        const data = await db.getObjectsFields(keys, ['email']);
        const emails = data.map(data => data && data.email).filter(Boolean);
        if (userData.email && emails.includes(userData.email)) {
            throw new Error('[[error:email-taken]]');
        }
    }

    async function sendNotificationToAdmins(username) {
        const notifObj = await notifications.create({
            type: 'new-register',
            bodyShort: `[[notifications:new_register, ${username}]]`,
            nid: `new_register:${username}`,
            path: '/admin/manage/registration',
            mergeId: 'new_register',
        });
        await notifications.pushGroup(notifObj, 'administrators');
    }

    User.acceptRegistration = async function (username) {
        const userData = await db.getObject(`registration:queue:name:${username}`);
        if (!userData) {
            throw new Error('[[error:invalid-data]]');
        }
        const creation_time = await db.sortedSetScore('registration:queue', username);
        const uid = await User.create(userData);
        await User.setUserFields(uid, {
            password: userData.hashedPassword,
            'password:shaWrapped': 1,
        });
        await removeFromQueue(username);
        await markNotificationRead(username);
        await plugins.hooks.fire('filter:register.complete', { uid: uid });
        await emailer.send('registration_accepted', uid, {
            username: username,
            subject: `[[email:welcome-to, ${meta.config.title || meta.config.browserTitle || 'NodeBB'}]]`,
            template: 'registration_accepted',
            uid: uid,
        }).catch(err => winston.error(`[emailer.send] ${err.stack}`));
        const total = await db.incrObjectFieldBy('registration:queue:approval:times', 'totalTime', Math.floor((Date.now() - creation_time) / 60000));
        const counter = await db.incrObjectField('registration:queue:approval:times', 'counter');
        await db.setObjectField('registration:queue:approval:times', 'average', total / counter);
        return uid;
    };

    async function markNotificationRead(username) {
        const nid = `new_register:${username}`;
        const uids = await groups.getMembers('administrators', 0, -1);
        const promises = uids.map(uid => notifications.markRead(nid, uid));
        await Promise.all(promises);
    }

    User.rejectRegistration = async function (username) {
        await removeFromQueue(username);
        await markNotificationRead(username);
    };

    async function removeFromQueue(username) {
        await Promise.all([
            db.sortedSetRemove('registration:queue', username),
            db.delete(`registration:queue:name:${username}`),
        ]);
    }

    User.shouldQueueUser = async function (ip) {
        const { registrationApprovalType } = meta.config;
        if (registrationApprovalType === 'admin-approval') {
            return true;
        } else if (registrationApprovalType === 'admin-approval-ip') {
            const count = await db.sortedSetCard(`ip:${ip}:uid`);
            return !!count;
        }
        return false;
    };

    User.getRegistrationQueue = async function (start, stop) {
        const data = await db.getSortedSetRevRangeWithScores('registration:queue', start, stop);
        const keys = data.filter(Boolean).map(user => `registration:queue:name:${user.value}`);
        let users = await db.getObjects(keys);
        users = users.filter(Boolean).map((user, index) => {
            user.timestampISO = utils.toISOString(data[index].score);
            user.email = validator.escape(String(user.email));
            user.usernameEscaped = validator.escape(String(user.username));
            delete user.hashedPassword;
            return user;
        });
        await Promise.all(users.map(async (user) => {
            // temporary: see http://www.stopforumspam.com/forum/viewtopic.php?id=6392
            // need to keep this for getIPMatchedUsers
            user.ip = user.ip.replace('::ffff:', '');
            await getIPMatchedUsers(user);
            user.customActions = [].concat(user.customActions);
            /*
                // then spam prevention plugins, using the "filter:user.getRegistrationQueue" hook can be like:
                user.customActions.push({
                    title: '[[spam-be-gone:report-user]]',
                    id: 'report-spam-user-' + user.username,
                    class: 'btn-warning report-spam-user',
                    icon: 'fa-flag'
                });
             */
        }));

        const results = await plugins.hooks.fire('filter:user.getRegistrationQueue', { users: users });
        return results.users;
    };

    async function getIPMatchedUsers(user) {
        const uids = await User.getUidsFromSet(`ip:${user.ip}:uid`, 0, -1);
        user.ipMatch = await User.getUsersFields(uids, ['uid', 'username', 'picture']);
    }

    User.autoApprove = async function () {
        if (meta.config.autoApproveTime <= 0) {
            return;
        }
        const users = await db.getSortedSetRevRangeWithScores('registration:queue', 0, -1);
        const now = Date.now();
        for (const user of users.filter(user => now - user.score >= meta.config.autoApproveTime * 3600000)) {
            // eslint-disable-next-line no-await-in-loop
            await User.acceptRegistration(user.value);
        }
    };
};

1	'use strict';
2
3	const validator = require('validator');	20✔
4	const winston = require('winston');	20✔
5	const cronJob = require('cron').CronJob;	20✔
6
7	const db = require('../database');	20✔
8	const meta = require('../meta');	20✔
9	const emailer = require('../emailer');	20✔
10	const notifications = require('../notifications');	20✔
11	const groups = require('../groups');	20✔
12	const utils = require('../utils');	20✔
13	const slugify = require('../slugify');	20✔
14	const plugins = require('../plugins');	20✔
15
16	module.exports = function (User) {	20✔
17	new cronJob('0 * * * *', (() => {	20✔
UNCOV 18	User.autoApprove();	×
19	}), null, true);
20
21	User.addToApprovalQueue = async function (userData) {	20✔
22	userData.username = userData.username.trim();	24✔
23	userData.userslug = slugify(userData.username);	24✔
24	await canQueue(userData);	24✔
25	const hashedPassword = await User.hashPassword(userData.password);	16✔
26	const data = {	16✔
27	username: userData.username,
28	email: userData.email,
29	ip: userData.ip,
30	hashedPassword: hashedPassword,
31	};
32	const results = await plugins.hooks.fire('filter:user.addToApprovalQueue', { data: data, userData: userData });	16✔
33	await db.setObject(`registration:queue:name:${userData.username}`, results.data);	16✔
34	await db.sortedSetAdd('registration:queue', Date.now(), userData.username);	16✔
35	await sendNotificationToAdmins(userData.username);	16✔
36	};
37
38	async function canQueue(userData) {
39	await User.isDataValid(userData);	24✔
40	const usernames = await db.getSortedSetRange('registration:queue', 0, -1);	24✔
41	if (usernames.includes(userData.username)) {	24✔
42	throw new Error('[[error:username-taken]]');	4✔
43	}
44	const keys = usernames.filter(Boolean).map(username => `registration:queue:name:${username}`);	20✔
45	const data = await db.getObjectsFields(keys, ['email']);	20✔
46	const emails = data.map(data => data && data.email).filter(Boolean);	20✔
47	if (userData.email && emails.includes(userData.email)) {	20✔
48	throw new Error('[[error:email-taken]]');	4✔
49	}
50	}
51
52	async function sendNotificationToAdmins(username) {
53	const notifObj = await notifications.create({	16✔
54	type: 'new-register',
55	bodyShort: `[[notifications:new_register, ${username}]]`,
56	nid: `new_register:${username}`,
57	path: '/admin/manage/registration',
58	mergeId: 'new_register',
59	});
60	await notifications.pushGroup(notifObj, 'administrators');	16✔
61	}
62
63	User.acceptRegistration = async function (username) {	20✔
64	const userData = await db.getObject(`registration:queue:name:${username}`);	4✔
65	if (!userData) {	4!
66	throw new Error('[[error:invalid-data]]');	×
67	}
68	const creation_time = await db.sortedSetScore('registration:queue', username);	4✔
69	const uid = await User.create(userData);	4✔
70	await User.setUserFields(uid, {	4✔
71	password: userData.hashedPassword,
72	'password:shaWrapped': 1,
73	});
74	await removeFromQueue(username);	4✔
75	await markNotificationRead(username);	4✔
76	await plugins.hooks.fire('filter:register.complete', { uid: uid });	4✔
77	await emailer.send('registration_accepted', uid, {	4✔
78	username: username,
79	subject: `[[email:welcome-to, ${meta.config.title \|\| meta.config.browserTitle \|\| 'NodeBB'}]]`,	4!
80	template: 'registration_accepted',
81	uid: uid,
82	}).catch(err => winston.error(`[emailer.send] ${err.stack}`));	×
83	const total = await db.incrObjectFieldBy('registration:queue:approval:times', 'totalTime', Math.floor((Date.now() - creation_time) / 60000));	4✔
84	const counter = await db.incrObjectField('registration:queue:approval:times', 'counter');	4✔
85	await db.setObjectField('registration:queue:approval:times', 'average', total / counter);	4✔
86	return uid;	4✔
87	};
88
89	async function markNotificationRead(username) {
90	const nid = `new_register:${username}`;	8✔
91	const uids = await groups.getMembers('administrators', 0, -1);	8✔
92	const promises = uids.map(uid => notifications.markRead(nid, uid));	48✔
93	await Promise.all(promises);	8✔
94	}
95
96	User.rejectRegistration = async function (username) {	20✔
97	await removeFromQueue(username);	4✔
98	await markNotificationRead(username);	4✔
99	};
100
101	async function removeFromQueue(username) {
102	await Promise.all([	8✔
103	db.sortedSetRemove('registration:queue', username),
104	db.delete(`registration:queue:name:${username}`),
105	]);
106	}
107
108	User.shouldQueueUser = async function (ip) {	20✔
109	const { registrationApprovalType } = meta.config;	44✔
110	if (registrationApprovalType === 'admin-approval') {	44✔
111	return true;	20✔
112	} else if (registrationApprovalType === 'admin-approval-ip') {	24✔
113	const count = await db.sortedSetCard(`ip:${ip}:uid`);	4✔
114	return !!count;	4✔
115	}
116	return false;	20✔
117	};
118
119	User.getRegistrationQueue = async function (start, stop) {	20✔
120	const data = await db.getSortedSetRevRangeWithScores('registration:queue', start, stop);	20✔
121	const keys = data.filter(Boolean).map(user => `registration:queue:name:${user.value}`);	20✔
122	let users = await db.getObjects(keys);	20✔
123	users = users.filter(Boolean).map((user, index) => {	20✔
124	user.timestampISO = utils.toISOString(data[index].score);	4✔
125	user.email = validator.escape(String(user.email));	4✔
126	user.usernameEscaped = validator.escape(String(user.username));	4✔
127	delete user.hashedPassword;	4✔
128	return user;	4✔
129	});
130	await Promise.all(users.map(async (user) => {	20✔
131	// temporary: see http://www.stopforumspam.com/forum/viewtopic.php?id=6392
132	// need to keep this for getIPMatchedUsers
133	user.ip = user.ip.replace('::ffff:', '');	4✔
134	await getIPMatchedUsers(user);	4✔
135	user.customActions = [].concat(user.customActions);	4✔
136	/*
137	// then spam prevention plugins, using the "filter:user.getRegistrationQueue" hook can be like:
138	user.customActions.push({
139	title: '[[spam-be-gone:report-user]]',
140	id: 'report-spam-user-' + user.username,
141	class: 'btn-warning report-spam-user',
142	icon: 'fa-flag'
143	});
144	*/
145	}));
146
147	const results = await plugins.hooks.fire('filter:user.getRegistrationQueue', { users: users });	20✔
148	return results.users;	20✔
149	};
150
151	async function getIPMatchedUsers(user) {
152	const uids = await User.getUidsFromSet(`ip:${user.ip}:uid`, 0, -1);	4✔
153	user.ipMatch = await User.getUsersFields(uids, ['uid', 'username', 'picture']);	4✔
154	}
155
156	User.autoApprove = async function () {	20✔
UNCOV 157	if (meta.config.autoApproveTime <= 0) {	×
UNCOV 158	return;	×
159	}
160	const users = await db.getSortedSetRevRangeWithScores('registration:queue', 0, -1);	×
161	const now = Date.now();	×
162	for (const user of users.filter(user => now - user.score >= meta.config.autoApproveTime * 3600000)) {	×
163	// eslint-disable-next-line no-await-in-loop
164	await User.acceptRegistration(user.value);	×
165	}
166	};
167	};

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

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