10692323943

Committed 03 Sep 2024 11:36PM UTC coverage: 82.665% (-0.006%) from 82.671%

Build # 10692323943

Build Type

Pull #438

github

Committed by

web-flow

Commit Message

Merge 0e86a9d5a into e7cfda55c

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

Run Details

9963 of 13474 branches covered (73.94%)

Branch coverage included in aggregate %.

23 of 28 new or added lines in 1 file covered. (82.14%)

2 existing lines in 2 files now uncovered.

22325 of 25585 relevant lines covered (87.26%)

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

CMU-313 / NodeBB / 10692323943

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