10692060175

Committed 03 Sep 2024 11:09PM UTC coverage: 82.67% (-0.001%) from 82.671%

Build # 10692060175

Build Type

Pull #438

github

Committed by

web-flow

Commit Message

Merge 1872a3a8f into e7cfda55c

Pull Request Pull Request #438: Refactored code in src/user/interstitials.js, resolves #434

Run Details

9964 of 13474 branches covered (73.95%)

Branch coverage included in aggregate %.

24 of 29 new or added lines in 1 file covered. (82.76%)

1 existing line in 1 file now uncovered.

22326 of 25585 relevant lines covered (87.26%)

1632.61 hits per line

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

76.92

/src/user/interstitials.js

'use strict';

const winston = require('winston');
const util = require('util');

const user = require('.');
const db = require('../database'); // Re-added the db module
const meta = require('../meta');
const privileges = require('../privileges');
const plugins = require('../plugins');
const utils = require('../utils');

const sleep = util.promisify(setTimeout);

const Interstitials = module.exports;

// Helper function to validate email format and permission
async function validateEmail(email, allowed, error) {
        if (!allowed || !utils.isEmailValid(email)) {
                throw new Error(error);
        }
}

// Helper function to check if email change is valid
async function checkEmailChange(userData, formData, confirmed, current) {
        if (formData.email === current) {
                if (confirmed) {
                        throw new Error('[[error:email-nochange]]');
                }
                if (!await user.email.canSendValidation(userData.uid, current)) {
                        throw new Error(`[[error:confirm-email-already-sent, ${meta.config.emailConfirmInterval}]]`);
                }
        }
}

// Helper function to send validation email
async function sendValidationEmail(userData, formData, hasPassword, isPasswordCorrect, isSelf, req) {
        if (hasPassword && !isPasswordCorrect) {
                throw new Error('[[error:invalid-password]]');
        }

        await user.email.sendValidationEmail(userData.uid, {
                email: formData.email,
                force: true,
        }).catch((err) => {
                winston.error(`[user.interstitials.email] Validation email failed to send\n[emailer.send] ${err.stack}`);
        });
        if (isSelf) {
                req.session.emailChanged = 1;
        }
}

// Main function to validate and send email
async function validateAndSendEmail(userData, formData, req, hasPassword, isSelf) {
        const [isPasswordCorrect, canEdit, { email: current, 'email:confirmed': confirmed }, { allowed, error }] = await Promise.all([
                user.isPasswordCorrect(userData.uid, formData.password, req.ip),
                privileges.users.canEdit(req.uid, userData.uid),
                user.getUserFields(userData.uid, ['email', 'email:confirmed']),
                plugins.hooks.fire('filter:user.saveEmail', {
                        uid: userData.uid,
                        email: formData.email,
                        registration: false,
                        allowed: true, // change this value to disallow
                        error: '[[error:invalid-email]]',
                }),
        ]);

        if (!isPasswordCorrect) await sleep(2000);

        if (formData.email && formData.email.length) {
                await validateEmail(formData.email, allowed, error);
                await checkEmailChange(userData, formData, confirmed, current);

                if (canEdit) {
                        await sendValidationEmail(userData, formData, hasPassword, isPasswordCorrect, isSelf, req);
                } else {
                        throw new Error('[[error:no-privileges]]');
                }
        } else {
                if (meta.config.requireEmailAddress) {
                        throw new Error('[[error:invalid-email]]');
                }

                if (current.length && (!hasPassword || (hasPassword && isPasswordCorrect))) {
                        await user.email.remove(userData.uid, isSelf ? req.session.id : null);
                }
        }
}

Interstitials.get = async (req, userData) => plugins.hooks.fire('filter:register.interstitial', {
        req,
        userData,
        interstitials: [],
});

Interstitials.email = async (data) => {
        if (!data.userData) {
                throw new Error('[[error:invalid-data]]');
        }
        if (!data.userData.updateEmail) {
                return data;
        }

        const [hasPassword, hasPending] = await Promise.all([
                user.hasPassword(data.userData.uid),
                user.email.isValidationPending(data.userData.uid),
        ]);

        let email;
        if (data.userData.uid) {
                email = await user.getUserField(data.userData.uid, 'email');
        }

        data.interstitials.push({
                template: 'partials/email_update',
                data: {
                        email,
                        requireEmailAddress: meta.config.requireEmailAddress,
                        issuePasswordChallenge: hasPassword,
                        hasPending,
                },
                callback: async (userData, formData) => {
                        if (formData.email) {
                                formData.email = String(formData.email).trim();
                        }

                        if (userData.uid) {
                                const isSelf = parseInt(userData.uid, 10) === parseInt(data.req.uid, 10);
                                await validateAndSendEmail(userData, formData, data.req, hasPassword, isSelf);
                        } else {
                                const { allowed, error } = await plugins.hooks.fire('filter:user.saveEmail', {
                                        uid: null,
                                        email: formData.email,
                                        registration: true,
                                        allowed: true, // change this value to disallow
                                        error: '[[error:invalid-email]]',
                                });

                                if (!allowed || (meta.config.requireEmailAddress && !(formData.email && formData.email.length))) {
                                        throw new Error(error);
                                }

                                userData.email = formData.email;
                        }

                        delete userData.updateEmail;
                },
        });

        return data;
};

Interstitials.gdpr = async (data) => {
        if (!meta.config.gdpr_enabled || (data.userData && data.userData.gdpr_consent)) {
                return data;
        }
        if (!data.userData) {
                throw new Error('[[error:invalid-data]]');
        }

        if (data.userData.uid) {
                const consented = await db.getObjectField(`user:${data.userData.uid}`, 'gdpr_consent');
                if (parseInt(consented, 10)) {
                        return data;
                }
        }

        data.interstitials.push({
                template: 'partials/gdpr_consent',
                data: {
                        digestFrequency: meta.config.dailyDigestFreq,
                        digestEnabled: meta.config.dailyDigestFreq !== 'off',
                },
                callback: (userData, formData, next) => {
                        if (formData.gdpr_agree_data === 'on' && formData.gdpr_agree_email === 'on') {
                                userData.gdpr_consent = true;
                        }
                        next(userData.gdpr_consent ? null : new Error('[[register:gdpr-consent-denied]]'));
                },
        });
        return data;
};

Interstitials.tou = async (data) => {
        if (!data.userData) {
                throw new Error('[[error:invalid-data]]');
        }
        if (!meta.config.termsOfUse || data.userData.acceptTos) {
                return data;
        }

        if (data.userData.uid) {
                const accepted = await db.getObjectField(`user:${data.userData.uid}`, 'acceptTos');
                if (parseInt(accepted, 10)) {
                        return data;
                }
        }

        const termsOfUse = await plugins.hooks.fire('filter:parse.post', {
                postData: {
                        content: meta.config.termsOfUse || '',
                },
        });

        data.interstitials.push({
                template: 'partials/acceptTos',
                data: {
                        termsOfUse: termsOfUse.postData.content,
                },
                callback: (userData, formData, next) => {
                        if (formData['agree-terms'] === 'on') {
                                userData.acceptTos = true;
                        }
                        next(userData.acceptTos ? null : new Error('[[register:terms-of-use-error]]'));
                },
        });
        return data;
};

1	'use strict';
2
3	const winston = require('winston');	8✔
4	const util = require('util');	8✔
5
6	const user = require('.');	8✔
7	const db = require('../database'); // Re-added the db module	8✔
8	const meta = require('../meta');	8✔
9	const privileges = require('../privileges');	8✔
10	const plugins = require('../plugins');	8✔
11	const utils = require('../utils');	8✔
12
13	const sleep = util.promisify(setTimeout);	8✔
14
15	const Interstitials = module.exports;	8✔
16
17	// Helper function to validate email format and permission
18	async function validateEmail(email, allowed, error) {
19	if (!allowed \|\| !utils.isEmailValid(email)) {	5✔
20	throw new Error(error);	1✔
21	}
22	}
23
24	// Helper function to check if email change is valid
25	async function checkEmailChange(userData, formData, confirmed, current) {
26	if (formData.email === current) {	4!
NEW 27	if (confirmed) {	×
NEW 28	throw new Error('[[error:email-nochange]]');	×
29	}
NEW 30	if (!await user.email.canSendValidation(userData.uid, current)) {	×
NEW 31	throw new Error(`[[error:confirm-email-already-sent, ${meta.config.emailConfirmInterval}]]`);	×
32	}
33	}
34	}
35
36	// Helper function to send validation email
37	async function sendValidationEmail(userData, formData, hasPassword, isPasswordCorrect, isSelf, req) {
38	if (hasPassword && !isPasswordCorrect) {	3✔
39	throw new Error('[[error:invalid-password]]');	1✔
40	}
41
42	await user.email.sendValidationEmail(userData.uid, {	2✔
43	email: formData.email,
44	force: true,
45	}).catch((err) => {
NEW 46	winston.error(`[user.interstitials.email] Validation email failed to send\n[emailer.send] ${err.stack}`);	×
47	});
48	if (isSelf) {	2!
49	req.session.emailChanged = 1;	2✔
50	}
51	}
52
53	// Main function to validate and send email
54	async function validateAndSendEmail(userData, formData, req, hasPassword, isSelf) {
55	const [isPasswordCorrect, canEdit, { email: current, 'email:confirmed': confirmed }, { allowed, error }] = await Promise.all([	8✔
56	user.isPasswordCorrect(userData.uid, formData.password, req.ip),
57	privileges.users.canEdit(req.uid, userData.uid),
58	user.getUserFields(userData.uid, ['email', 'email:confirmed']),
59	plugins.hooks.fire('filter:user.saveEmail', {
60	uid: userData.uid,
61	email: formData.email,
62	registration: false,
63	allowed: true, // change this value to disallow
64	error: '[[error:invalid-email]]',
65	}),
66	]);
67
68	if (!isPasswordCorrect) await sleep(2000);	8✔
69
70	if (formData.email && formData.email.length) {	8✔
71	await validateEmail(formData.email, allowed, error);	5✔
72	await checkEmailChange(userData, formData, confirmed, current);	4✔
73
74	if (canEdit) {	4✔
75	await sendValidationEmail(userData, formData, hasPassword, isPasswordCorrect, isSelf, req);	3✔
76	} else {
77	throw new Error('[[error:no-privileges]]');	1✔
78	}
79	} else {
80	if (meta.config.requireEmailAddress) {	3✔
81	throw new Error('[[error:invalid-email]]');	1✔
82	}
83
84	if (current.length && (!hasPassword \|\| (hasPassword && isPasswordCorrect))) {	2✔
85	await user.email.remove(userData.uid, isSelf ? req.session.id : null);	1!
86	}
87	}
88	}
89
90	Interstitials.get = async (req, userData) => plugins.hooks.fire('filter:register.interstitial', {	32✔
91	req,
92	userData,
93	interstitials: [],
94	});
95
96	Interstitials.email = async (data) => {	8✔
97	if (!data.userData) {	41✔
98	throw new Error('[[error:invalid-data]]');	1✔
99	}
100	if (!data.userData.updateEmail) {	40✔
101	return data;	20✔
102	}
103
104	const [hasPassword, hasPending] = await Promise.all([	20✔
105	user.hasPassword(data.userData.uid),
106	user.email.isValidationPending(data.userData.uid),
107	]);
108
109	let email;
110	if (data.userData.uid) {	20✔
111	email = await user.getUserField(data.userData.uid, 'email');	9✔
112	}
113
114	data.interstitials.push({	20✔
115	template: 'partials/email_update',
116	data: {
117	email,
118	requireEmailAddress: meta.config.requireEmailAddress,
119	issuePasswordChallenge: hasPassword,
120	hasPending,
121	},
122	callback: async (userData, formData) => {
123	if (formData.email) {	12✔
124	formData.email = String(formData.email).trim();	7✔
125	}
126
127	if (userData.uid) {	12✔
128	const isSelf = parseInt(userData.uid, 10) === parseInt(data.req.uid, 10);	8✔
129	await validateAndSendEmail(userData, formData, data.req, hasPassword, isSelf);	8✔
130	} else {
131	const { allowed, error } = await plugins.hooks.fire('filter:user.saveEmail', {	4✔
132	uid: null,
133	email: formData.email,
134	registration: true,
135	allowed: true, // change this value to disallow
136	error: '[[error:invalid-email]]',
137	});
138
139	if (!allowed \|\| (meta.config.requireEmailAddress && !(formData.email && formData.email.length))) {	4!
140	throw new Error(error);	1✔
141	}
142
143	userData.email = formData.email;	3✔
144	}
145
146	delete userData.updateEmail;	7✔
147	},
148	});
149
150	return data;	20✔
151	};
152
153	Interstitials.gdpr = async (data) => {	8✔
154	if (!meta.config.gdpr_enabled \|\| (data.userData && data.userData.gdpr_consent)) {	32✔
155	return data;	13✔
156	}
157	if (!data.userData) {	19!
158	throw new Error('[[error:invalid-data]]');	×
159	}
160
161	if (data.userData.uid) {	19✔
162	const consented = await db.getObjectField(`user:${data.userData.uid}`, 'gdpr_consent');	6✔
163	if (parseInt(consented, 10)) {	6✔
164	return data;	5✔
165	}
166	}
167
168	data.interstitials.push({	14✔
169	template: 'partials/gdpr_consent',
170	data: {
171	digestFrequency: meta.config.dailyDigestFreq,
172	digestEnabled: meta.config.dailyDigestFreq !== 'off',
173	},
174	callback: (userData, formData, next) => {
175	if (formData.gdpr_agree_data === 'on' && formData.gdpr_agree_email === 'on') {	4✔
176	userData.gdpr_consent = true;	3✔
177	}
178	next(userData.gdpr_consent ? null : new Error('[[register:gdpr-consent-denied]]'));	4✔
179	},
180	});
181	return data;	14✔
182	};
183
184	Interstitials.tou = async (data) => {	8✔
185	if (!data.userData) {	32!
186	throw new Error('[[error:invalid-data]]');	×
187	}
188	if (!meta.config.termsOfUse \|\| data.userData.acceptTos) {	32!
189	return data;	32✔
190	}
191
192	if (data.userData.uid) {	×
193	const accepted = await db.getObjectField(`user:${data.userData.uid}`, 'acceptTos');	×
194	if (parseInt(accepted, 10)) {	×
195	return data;	×
196	}
197	}
198
199	const termsOfUse = await plugins.hooks.fire('filter:parse.post', {	×
200	postData: {
201	content: meta.config.termsOfUse \|\| '',	×
202	},
203	});
204
205	data.interstitials.push({	×
206	template: 'partials/acceptTos',
207	data: {
208	termsOfUse: termsOfUse.postData.content,
209	},
210	callback: (userData, formData, next) => {
211	if (formData['agree-terms'] === 'on') {	×
212	userData.acceptTos = true;	×
213	}
UNCOV 214	next(userData.acceptTos ? null : new Error('[[register:terms-of-use-error]]'));	×
215	},
216	});
217	return data;	×
218	};

CMU-313 / NodeBB / 10692060175

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