10691877513

Committed 03 Sep 2024 10:51PM UTC coverage: 82.671%. Remained the same

Build # 10691877513

Build Type

Pull #438

github

Committed by

web-flow

Commit Message

Merge 04db40ed4 into e7cfda55c

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

Run Details

9965 of 13474 branches covered (73.96%)

Branch coverage included in aggregate %.

39 of 45 new or added lines in 1 file covered. (86.67%)

1 existing line in 1 file now uncovered.

22323 of 25582 relevant lines covered (87.26%)

1632.8 hits per line

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

76.51

/src/user/interstitials.js

'use strict';

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

const user = require('.');
const db = require('../database');
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 and send email
async function validateAndSendEmail(userData, formData, data, hasPassword, isSelf) {
        const [isPasswordCorrect, canEdit, { email: current, 'email:confirmed': confirmed }, { allowed, error }] = await Promise.all([
                user.isPasswordCorrect(userData.uid, formData.password, data.req.ip),
                privileges.users.canEdit(data.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) {
                if (!allowed || !utils.isEmailValid(formData.email)) {
                        throw new Error(error);
                }

                if (formData.email === current) {
                        if (confirmed) {
                                throw new Error('[[error:email-nochange]]');
                        } else if (!await user.email.canSendValidation(userData.uid, current)) {
                                throw new Error(`[[error:confirm-email-already-sent, ${meta.config.emailConfirmInterval}]]`);
                        }
                }

                if (canEdit) {
                        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) {
                                data.req.session.emailChanged = 1;
                        }
                } 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 ? data.req.session.id : null);
                }
        }
}

// Helper function to check GDPR consent
async function checkGdprConsent(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;
}

// Helper function to check Terms of Use acceptance
async function checkTermsOfUse(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;
}

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, 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 = checkGdprConsent;

Interstitials.tou = checkTermsOfUse;

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

CMU-313 / NodeBB / 10691877513

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