10692281656

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

Build # 10692281656

Build Type

Pull #405

github

Committed by

web-flow

Commit Message

Merge 2cf9c1bb3 into e7cfda55c

Pull Request Pull Request #405: refactored code in src/user/data.js - changed if statements to functions

Run Details

9964 of 13474 branches covered (73.95%)

Branch coverage included in aggregate %.

29 of 33 new or added lines in 1 file covered. (87.88%)

3 existing lines in 1 file now uncovered.

22326 of 25585 relevant lines covered (87.26%)

1633.05 hits per line

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

90.14

/src/user/data.js

'use strict';

const validator = require('validator');
const nconf = require('nconf');
const _ = require('lodash');

const db = require('../database');
const meta = require('../meta');
const plugins = require('../plugins');
const utils = require('../utils');

const relative_path = nconf.get('relative_path');

const intFields = [
        'uid', 'postcount', 'topiccount', 'reputation', 'profileviews',
        'banned', 'banned:expire', 'email:confirmed', 'joindate', 'lastonline',
        'lastqueuetime', 'lastposttime', 'followingCount', 'followerCount',
        'blocksCount', 'passwordExpiry', 'mutedUntil',
];

module.exports = function (User) {
        const fieldWhitelist = [
                'uid', 'username', 'userslug', 'email', 'email:confirmed', 'joindate',
                'lastonline', 'picture', 'icon:bgColor', 'fullname', 'location', 'birthday', 'website',
                'aboutme', 'signature', 'uploadedpicture', 'profileviews', 'reputation',
                'postcount', 'topiccount', 'lastposttime', 'banned', 'banned:expire',
                'status', 'flags', 'followerCount', 'followingCount', 'cover:url',
                'cover:position', 'groupTitle', 'mutedUntil', 'mutedReason',
        ];

        User.guestData = {
                uid: 0,
                username: '[[global:guest]]',
                displayname: '[[global:guest]]',
                userslug: '',
                fullname: '[[global:guest]]',
                email: '',
                'icon:text': '?',
                'icon:bgColor': '#aaa',
                groupTitle: '',
                groupTitleArray: [],
                status: 'offline',
                reputation: 0,
                'email:confirmed': 0,
        };

        let iconBackgrounds;

        User.getUsersFields = async function (uids, fields) {
                if (!Array.isArray(uids) || !uids.length) {
                        return [];
                }

                uids = uids.map(uid => (isNaN(uid) ? 0 : parseInt(uid, 10)));

                const fieldsToRemove = [];
                fields = fields.slice();
                ensureRequiredFields(fields, fieldsToRemove);

                const uniqueUids = _.uniq(uids).filter(uid => uid > 0);

                const results = await plugins.hooks.fire('filter:user.whitelistFields', {
                        uids: uids,
                        whitelist: fieldWhitelist.slice(),
                });
                if (!fields.length) {
                        fields = results.whitelist;
                } else {
                        // Never allow password retrieval via this method
                        fields = fields.filter(value => value !== 'password');
                }

                const users = await db.getObjectsFields(uniqueUids.map(uid => `user:${uid}`), fields);
                const result = await plugins.hooks.fire('filter:user.getFields', {
                        uids: uniqueUids,
                        users: users,
                        fields: fields,
                });
                result.users.forEach((user, index) => {
                        if (uniqueUids[index] > 0 && !user.uid) {
                                user.oldUid = uniqueUids[index];
                        }
                });
                await modifyUserData(result.users, fields, fieldsToRemove);
                return uidsToUsers(uids, uniqueUids, result.users);
        };

        function ensureRequiredFields(fields, fieldsToRemove) {
                function addField(field) {
                        if (!fields.includes(field)) {
                                fields.push(field);
                                fieldsToRemove.push(field);
                        }
                }

                if (fields.length && !fields.includes('uid')) {
                        fields.push('uid');
                }

                if (fields.includes('picture')) {
                        addField('uploadedpicture');
                }

                if (fields.includes('status')) {
                        addField('lastonline');
                }

                if (fields.includes('banned') && !fields.includes('banned:expire')) {
                        addField('banned:expire');
                }

                if (fields.includes('username') && !fields.includes('fullname')) {
                        addField('fullname');
                }
        }

        function uidsToUsers(uids, uniqueUids, usersData) {
                const uidToUser = _.zipObject(uniqueUids, usersData);
                const users = uids.map((uid) => {
                        const user = uidToUser[uid] || { ...User.guestData };
                        if (!parseInt(user.uid, 10)) {
                                user.username = (user.hasOwnProperty('oldUid') && parseInt(user.oldUid, 10)) ? '[[global:former-user]]' : '[[global:guest]]';
                                user.displayname = user.username;
                        }
                        if (uid === -1) { // if loading spider set uid to -1 otherwise spiders have uid = 0 like guests
                                user.uid = -1;
                        }
                        return user;
                });
                return users;
        }

        User.getUserField = async function (uid, field) {
                const user = await User.getUserFields(uid, [field]);
                return user ? user[field] : null;
        };

        User.getUserFields = async function (uid, fields) {
                const users = await User.getUsersFields([uid], fields);
                return users ? users[0] : null;
        };

        User.getUserData = async function (uid) {
                const users = await User.getUsersData([uid]);
                return users ? users[0] : null;
        };

        User.getUsersData = async function (uids) {
                return await User.getUsersFields(uids, []);
        };

        User.hidePrivateData = async function (users, callerUID) {
                let single = false;
                if (!Array.isArray(users)) {
                        users = [users];
                        single = true;
                }

                const [userSettings, isAdmin, isGlobalModerator] = await Promise.all([
                        User.getMultipleUserSettings(users.map(user => user.uid)),
                        User.isAdministrator(callerUID),
                        User.isGlobalModerator(callerUID),
                ]);

                users = await Promise.all(users.map(async (userData, idx) => {
                        const _userData = { ...userData };

                        const isSelf = parseInt(callerUID, 10) === parseInt(_userData.uid, 10);
                        const privilegedOrSelf = isAdmin || isGlobalModerator || isSelf;

                        if (!privilegedOrSelf && (!userSettings[idx].showemail || meta.config.hideEmail)) {
                                _userData.email = '';
                        }
                        if (!privilegedOrSelf && (!userSettings[idx].showfullname || meta.config.hideFullname)) {
                                _userData.fullname = '';
                        }
                        return _userData;
                }));

                return single ? users.pop() : users;
        };

        async function modifyUserData(users, requestedFields, fieldsToRemove) {
                let uidToSettings = {};
                if (meta.config.showFullnameAsDisplayName) {
                        const uids = users.map(user => user.uid);
                        uidToSettings = _.zipObject(uids, await db.getObjectsFields(
                                uids.map(uid => `user:${uid}:settings`),
                                ['showfullname']
                        ));
                }
                if (!iconBackgrounds) {
                        iconBackgrounds = await User.getIconBackgrounds();
                }

                const unbanUids = [];
                users.forEach((user) => {
                        if (!user) {
                                return;
                        }

                        db.parseIntFields(user, intFields, requestedFields);

                        if (user.hasOwnProperty('username')) {
                                parseDisplayName(user, uidToSettings);
                                user.username = validator.escape(user.username ? user.username.toString() : '');
                        }

                        if (user.hasOwnProperty('email')) {
                                user.email = validator.escape(user.email ? user.email.toString() : '');
                        }

                        if (!user.uid) {
                                for (const [key, value] of Object.entries(User.guestData)) {
                                        user[key] = value;
                                }
                                user.picture = User.getDefaultAvatar();
                        }

                        if (user.hasOwnProperty('groupTitle')) {
                                parseGroupTitle(user);
                        }

                        if (user.picture && user.picture === user.uploadedpicture) {
                                user.uploadedpicture = user.picture.startsWith('http') ? user.picture : relative_path + user.picture;
                                user.picture = user.uploadedpicture;
                        } else if (user.uploadedpicture) {
                                user.uploadedpicture = user.uploadedpicture.startsWith('http') ? user.uploadedpicture : relative_path + user.uploadedpicture;
                        }
                        if (meta.config.defaultAvatar && !user.picture) {
                                user.picture = User.getDefaultAvatar();
                        }
                        if (user.hasOwnProperty('status') && user.hasOwnProperty('lastonline')) {
                                user.status = User.getStatus(user);
                        }

                        for (let i = 0; i < fieldsToRemove.length; i += 1) {
                                user[fieldsToRemove[i]] = undefined;
                        }
                        handleUserIcons(user, requestedFields);
                        handleDates(user);
                        handleMuteAndBan(user, unbanUids);
                });

                if (unbanUids.length) {
                        await User.bans.unban(unbanUids, '[[user:info.ban-expired]]');
                }

                return await plugins.hooks.fire('filter:users.get', users);
        }

        function handleUserIcons(user, requestedFields) {
                if (requestedFields.includes('picture') && user.username && user.uid && !meta.config.defaultAvatar) {
                        if (!iconBackgrounds.includes(user['icon:bgColor'])) {
                                const nameAsIndex = Array.from(user.username).reduce((cur, next) => cur + next.charCodeAt(), 0);
                                user['icon:bgColor'] = iconBackgrounds[nameAsIndex % iconBackgrounds.length];
                        }
                        user['icon:text'] = (user.username[0] || '').toUpperCase();
                }
        }

        function handleDates(user) {
                if (user.hasOwnProperty('joindate')) {
                        user.joindateISO = utils.toISOString(user.joindate);
                }

                if (user.hasOwnProperty('lastonline')) {
                        user.lastonlineISO = utils.toISOString(user.lastonline) || user.joindateISO;
                }
        }

        function handleMuteAndBan(user, unbanUids) {
                if (user.hasOwnProperty('mutedUntil')) {
                        user.muted = user.mutedUntil > Date.now();
                }

                if (user.hasOwnProperty('banned') || user.hasOwnProperty('banned:expire')) {
                        const result = User.bans.calcExpiredFromUserData(user);
                        user.banned = result.banned;
                        const unban = result.banned && result.banExpired;
                        user.banned_until = unban ? 0 : user['banned:expire'];
                        user.banned_until_readable = user.banned_until && !unban ? utils.toISOString(user.banned_until) : 'Not Banned';
                        if (unban) {
                                unbanUids.push(user.uid);
                                user.banned = false;
                        }
                }
        }


        function parseDisplayName(user, uidToSettings) {
                let showfullname = parseInt(meta.config.showfullname, 10) === 1;
                if (uidToSettings[user.uid]) {
                        if (parseInt(uidToSettings[user.uid].showfullname, 10) === 0) {
                                showfullname = false;
                        } else if (parseInt(uidToSettings[user.uid].showfullname, 10) === 1) {
                                showfullname = true;
                        }
                }

                user.displayname = validator.escape(String(
                        meta.config.showFullnameAsDisplayName && showfullname && user.fullname ?
                                user.fullname :
                                user.username
                ));
        }

        function parseGroupTitle(user) {
                try {
                        user.groupTitleArray = JSON.parse(user.groupTitle);
                } catch (err) {
                        if (user.groupTitle) {
                                user.groupTitleArray = [user.groupTitle];
                        } else {
                                user.groupTitle = '';
                                user.groupTitleArray = [];
                        }
                }
                if (!Array.isArray(user.groupTitleArray)) {
                        if (user.groupTitleArray) {
                                user.groupTitleArray = [user.groupTitleArray];
                        } else {
                                user.groupTitleArray = [];
                        }
                }
                if (!meta.config.allowMultipleBadges && user.groupTitleArray.length) {
                        user.groupTitleArray = [user.groupTitleArray[0]];
                }
        }


        User.getIconBackgrounds = async () => {
                if (iconBackgrounds) {
                        return iconBackgrounds;
                }

                const _iconBackgrounds = [
                        '#f44336', '#e91e63', '#9c27b0', '#673ab7', '#3f51b5', '#2196f3',
                        '#009688', '#1b5e20', '#33691e', '#827717', '#e65100', '#ff5722',
                        '#795548', '#607d8b',
                ];

                const data = await plugins.hooks.fire('filter:user.iconBackgrounds', { iconBackgrounds: _iconBackgrounds });
                iconBackgrounds = data.iconBackgrounds;
                return iconBackgrounds;
        };

        User.getDefaultAvatar = function () {
                if (!meta.config.defaultAvatar) {
                        return '';
                }
                return meta.config.defaultAvatar.startsWith('http') ? meta.config.defaultAvatar : relative_path + meta.config.defaultAvatar;
        };

        User.setUserField = async function (uid, field, value) {
                await User.setUserFields(uid, { [field]: value });
        };

        User.setUserFields = async function (uid, data) {
                await db.setObject(`user:${uid}`, data);
                for (const [field, value] of Object.entries(data)) {
                        plugins.hooks.fire('action:user.set', { uid, field, value, type: 'set' });
                }
        };

        User.incrementUserFieldBy = async function (uid, field, value) {
                return await incrDecrUserFieldBy(uid, field, value, 'increment');
        };

        User.decrementUserFieldBy = async function (uid, field, value) {
                return await incrDecrUserFieldBy(uid, field, -value, 'decrement');
        };

        async function incrDecrUserFieldBy(uid, field, value, type) {
                const newValue = await db.incrObjectFieldBy(`user:${uid}`, field, value);
                plugins.hooks.fire('action:user.set', { uid: uid, field: field, value: newValue, type: type });
                return newValue;
        }
};

1	'use strict';
2
3	const validator = require('validator');	8✔
4	const nconf = require('nconf');	8✔
5	const _ = require('lodash');	8✔
6
7	const db = require('../database');	8✔
8	const meta = require('../meta');	8✔
9	const plugins = require('../plugins');	8✔
10	const utils = require('../utils');	8✔
11
12	const relative_path = nconf.get('relative_path');	8✔
13
14	const intFields = [	8✔
15	'uid', 'postcount', 'topiccount', 'reputation', 'profileviews',
16	'banned', 'banned:expire', 'email:confirmed', 'joindate', 'lastonline',
17	'lastqueuetime', 'lastposttime', 'followingCount', 'followerCount',
18	'blocksCount', 'passwordExpiry', 'mutedUntil',
19	];
20
21	module.exports = function (User) {	8✔
22	const fieldWhitelist = [	8✔
23	'uid', 'username', 'userslug', 'email', 'email:confirmed', 'joindate',
24	'lastonline', 'picture', 'icon:bgColor', 'fullname', 'location', 'birthday', 'website',
25	'aboutme', 'signature', 'uploadedpicture', 'profileviews', 'reputation',
26	'postcount', 'topiccount', 'lastposttime', 'banned', 'banned:expire',
27	'status', 'flags', 'followerCount', 'followingCount', 'cover:url',
28	'cover:position', 'groupTitle', 'mutedUntil', 'mutedReason',
29	];
30
31	User.guestData = {	8✔
32	uid: 0,
33	username: '[[global:guest]]',
34	displayname: '[[global:guest]]',
35	userslug: '',
36	fullname: '[[global:guest]]',
37	email: '',
38	'icon:text': '?',
39	'icon:bgColor': '#aaa',
40	groupTitle: '',
41	groupTitleArray: [],
42	status: 'offline',
43	reputation: 0,
44	'email:confirmed': 0,
45	};
46
47	let iconBackgrounds;
48
49	User.getUsersFields = async function (uids, fields) {	8✔
50	if (!Array.isArray(uids) \|\| !uids.length) {	4,144✔
51	return [];	624✔
52	}
53
54	uids = uids.map(uid => (isNaN(uid) ? 0 : parseInt(uid, 10)));	3,998✔
55
56	const fieldsToRemove = [];	3,520✔
57	fields = fields.slice();	3,520✔
58	ensureRequiredFields(fields, fieldsToRemove);	3,520✔
59
60	const uniqueUids = _.uniq(uids).filter(uid => uid > 0);	3,871✔
61
62	const results = await plugins.hooks.fire('filter:user.whitelistFields', {	3,520✔
63	uids: uids,
64	whitelist: fieldWhitelist.slice(),
65	});
66	if (!fields.length) {	3,520✔
67	fields = results.whitelist;	551✔
68	} else {
69	// Never allow password retrieval via this method
70	fields = fields.filter(value => value !== 'password');	18,477✔
71	}
72
73	const users = await db.getObjectsFields(uniqueUids.map(uid => `user:${uid}`), fields);	3,768✔
74	const result = await plugins.hooks.fire('filter:user.getFields', {	3,520✔
75	uids: uniqueUids,
76	users: users,
77	fields: fields,
78	});
79	result.users.forEach((user, index) => {	3,520✔
80	if (uniqueUids[index] > 0 && !user.uid) {	3,768✔
81	user.oldUid = uniqueUids[index];	10✔
82	}
83	});
84	await modifyUserData(result.users, fields, fieldsToRemove);	3,520✔
85	return uidsToUsers(uids, uniqueUids, result.users);	3,520✔
86	};
87
88	function ensureRequiredFields(fields, fieldsToRemove) {
89	function addField(field) {
90	if (!fields.includes(field)) {	3,032✔
91	fields.push(field);	2,617✔
92	fieldsToRemove.push(field);	2,617✔
93	}
94	}
95
96	if (fields.length && !fields.includes('uid')) {	3,520✔
97	fields.push('uid');	1,779✔
98	}
99
100	if (fields.includes('picture')) {	3,520✔
101	addField('uploadedpicture');	1,062✔
102	}
103
104	if (fields.includes('status')) {	3,520✔
105	addField('lastonline');	791✔
106	}
107
108	if (fields.includes('banned') && !fields.includes('banned:expire')) {	3,520✔
109	addField('banned:expire');	420✔
110	}
111
112	if (fields.includes('username') && !fields.includes('fullname')) {	3,520✔
113	addField('fullname');	759✔
114	}
115	}
116
117	function uidsToUsers(uids, uniqueUids, usersData) {
118	const uidToUser = _.zipObject(uniqueUids, usersData);	3,520✔
119	const users = uids.map((uid) => {	3,520✔
120	const user = uidToUser[uid] \|\| { ...User.guestData };	3,998✔
121	if (!parseInt(user.uid, 10)) {	3,998✔
122	user.username = (user.hasOwnProperty('oldUid') && parseInt(user.oldUid, 10)) ? '[[global:former-user]]' : '[[global:guest]]';	115✔
123	user.displayname = user.username;	115✔
124	}
125	if (uid === -1) { // if loading spider set uid to -1 otherwise spiders have uid = 0 like guests	3,998!
126	user.uid = -1;	×
127	}
128	return user;	3,998✔
129	});
130	return users;	3,520✔
131	}
132
133	User.getUserField = async function (uid, field) {	8✔
134	const user = await User.getUserFields(uid, [field]);	967✔
135	return user ? user[field] : null;	967!
136	};
137
138	User.getUserFields = async function (uid, fields) {	8✔
139	const users = await User.getUsersFields([uid], fields);	1,625✔
140	return users ? users[0] : null;	1,625!
141	};
142
143	User.getUserData = async function (uid) {	8✔
144	const users = await User.getUsersData([uid]);	537✔
145	return users ? users[0] : null;	537!
146	};
147
148	User.getUsersData = async function (uids) {	8✔
149	return await User.getUsersFields(uids, []);	552✔
150	};
151
152	User.hidePrivateData = async function (users, callerUID) {	8✔
153	let single = false;	203✔
154	if (!Array.isArray(users)) {	203✔
155	users = [users];	126✔
156	single = true;	126✔
157	}
158
159	const [userSettings, isAdmin, isGlobalModerator] = await Promise.all([	203✔
160	User.getMultipleUserSettings(users.map(user => user.uid)),	174✔
161	User.isAdministrator(callerUID),
162	User.isGlobalModerator(callerUID),
163	]);
164
165	users = await Promise.all(users.map(async (userData, idx) => {	203✔
166	const _userData = { ...userData };	174✔
167
168	const isSelf = parseInt(callerUID, 10) === parseInt(_userData.uid, 10);	174✔
169	const privilegedOrSelf = isAdmin \|\| isGlobalModerator \|\| isSelf;	174✔
170
171	if (!privilegedOrSelf && (!userSettings[idx].showemail \|\| meta.config.hideEmail)) {	174✔
172	_userData.email = '';	44✔
173	}
174	if (!privilegedOrSelf && (!userSettings[idx].showfullname \|\| meta.config.hideFullname)) {	174✔
175	_userData.fullname = '';	45✔
176	}
177	return _userData;	174✔
178	}));
179
180	return single ? users.pop() : users;	203✔
181	};
182
183	async function modifyUserData(users, requestedFields, fieldsToRemove) {
184	let uidToSettings = {};	3,520✔
185	if (meta.config.showFullnameAsDisplayName) {	3,520!
186	const uids = users.map(user => user.uid);	×
187	uidToSettings = _.zipObject(uids, await db.getObjectsFields(	×
188	uids.map(uid => `user:${uid}:settings`),	×
189	['showfullname']
190	));
191	}
192	if (!iconBackgrounds) {	3,520✔
193	iconBackgrounds = await User.getIconBackgrounds();	3✔
194	}
195
196	const unbanUids = [];	3,520✔
197	users.forEach((user) => {	3,520✔
198	if (!user) {	3,768!
199	return;	×
200	}
201
202	db.parseIntFields(user, intFields, requestedFields);	3,768✔
203
204	if (user.hasOwnProperty('username')) {	3,768✔
205	parseDisplayName(user, uidToSettings);	2,115✔
206	user.username = validator.escape(user.username ? user.username.toString() : '');	2,115✔
207	}
208
209	if (user.hasOwnProperty('email')) {	3,768✔
210	user.email = validator.escape(user.email ? user.email.toString() : '');	1,028✔
211	}
212
213	if (!user.uid) {	3,768✔
214	for (const [key, value] of Object.entries(User.guestData)) {	10✔
215	user[key] = value;	130✔
216	}
217	user.picture = User.getDefaultAvatar();	10✔
218	}
219
220	if (user.hasOwnProperty('groupTitle')) {	3,768✔
221	parseGroupTitle(user);	928✔
222	}
223
224	if (user.picture && user.picture === user.uploadedpicture) {	3,768✔
225	user.uploadedpicture = user.picture.startsWith('http') ? user.picture : relative_path + user.picture;	9!
226	user.picture = user.uploadedpicture;	9✔
227	} else if (user.uploadedpicture) {	3,759✔
228	user.uploadedpicture = user.uploadedpicture.startsWith('http') ? user.uploadedpicture : relative_path + user.uploadedpicture;	18!
229	}
230	if (meta.config.defaultAvatar && !user.picture) {	3,768!
UNCOV 231	user.picture = User.getDefaultAvatar();	×
232	}
233	if (user.hasOwnProperty('status') && user.hasOwnProperty('lastonline')) {	3,768✔
234	user.status = User.getStatus(user);	1,429✔
235	}
236
237	for (let i = 0; i < fieldsToRemove.length; i += 1) {	3,768✔
238	user[fieldsToRemove[i]] = undefined;	3,125✔
239	}
240	handleUserIcons(user, requestedFields);	3,768✔
241	handleDates(user);	3,768✔
242	handleMuteAndBan(user, unbanUids);	3,768✔
243	});
244
245	if (unbanUids.length) {	3,520✔
246	await User.bans.unban(unbanUids, '[[user:info.ban-expired]]');	1✔
247	}
248
249	return await plugins.hooks.fire('filter:users.get', users);	3,520✔
250	}
251
252	function handleUserIcons(user, requestedFields) {
253	if (requestedFields.includes('picture') && user.username && user.uid && !meta.config.defaultAvatar) {	3,768✔
254	if (!iconBackgrounds.includes(user['icon:bgColor'])) {	1,784✔
255	const nameAsIndex = Array.from(user.username).reduce((cur, next) => cur + next.charCodeAt(), 0);	12,473✔
256	user['icon:bgColor'] = iconBackgrounds[nameAsIndex % iconBackgrounds.length];	1,765✔
257	}
258	user['icon:text'] = (user.username[0] \|\| '').toUpperCase();	1,784!
259	}
260	}
261
262	function handleDates(user) {
263	if (user.hasOwnProperty('joindate')) {	3,768✔
264	user.joindateISO = utils.toISOString(user.joindate);	838✔
265	}
266
267	if (user.hasOwnProperty('lastonline')) {	3,768✔
268	user.lastonlineISO = utils.toISOString(user.lastonline) \|\| user.joindateISO;	1,459✔
269	}
270	}
271
272	function handleMuteAndBan(user, unbanUids) {
273	if (user.hasOwnProperty('mutedUntil')) {	3,768✔
274	user.muted = user.mutedUntil > Date.now();	1,298✔
275	}
276
277	if (user.hasOwnProperty('banned') \|\| user.hasOwnProperty('banned:expire')) {	3,768✔
278	const result = User.bans.calcExpiredFromUserData(user);	1,847✔
279	user.banned = result.banned;	1,847✔
280	const unban = result.banned && result.banExpired;	1,847✔
281	user.banned_until = unban ? 0 : user['banned:expire'];	1,847✔
282	user.banned_until_readable = user.banned_until && !unban ? utils.toISOString(user.banned_until) : 'Not Banned';	1,847✔
283	if (unban) {	1,847✔
284	unbanUids.push(user.uid);	1✔
285	user.banned = false;	1✔
286	}
287	}
288	}
289
290
291	function parseDisplayName(user, uidToSettings) {
292	let showfullname = parseInt(meta.config.showfullname, 10) === 1;	2,115✔
293	if (uidToSettings[user.uid]) {	2,115!
NEW 294	if (parseInt(uidToSettings[user.uid].showfullname, 10) === 0) {	×
NEW 295	showfullname = false;	×
NEW 296	} else if (parseInt(uidToSettings[user.uid].showfullname, 10) === 1) {	×
NEW 297	showfullname = true;	×
298	}
299	}
300
301	user.displayname = validator.escape(String(	2,115✔
302	meta.config.showFullnameAsDisplayName && showfullname && user.fullname ?	4,230!
303	user.fullname :
304	user.username
305	));
306	}
307
308	function parseGroupTitle(user) {
309	try {	928✔
310	user.groupTitleArray = JSON.parse(user.groupTitle);	928✔
311	} catch (err) {
312	if (user.groupTitle) {	11✔
313	user.groupTitleArray = [user.groupTitle];	1✔
314	} else {
315	user.groupTitle = '';	10✔
316	user.groupTitleArray = [];	10✔
317	}
318	}
319	if (!Array.isArray(user.groupTitleArray)) {	928✔
320	if (user.groupTitleArray) {	406!
UNCOV 321	user.groupTitleArray = [user.groupTitleArray];	×
322	} else {
323	user.groupTitleArray = [];	406✔
324	}
325	}
326	if (!meta.config.allowMultipleBadges && user.groupTitleArray.length) {	928!
UNCOV 327	user.groupTitleArray = [user.groupTitleArray[0]];	×
328	}
329	}
330
331
332	User.getIconBackgrounds = async () => {	8✔
333	if (iconBackgrounds) {	107✔
334	return iconBackgrounds;	104✔
335	}
336
337	const _iconBackgrounds = [	3✔
338	'#f44336', '#e91e63', '#9c27b0', '#673ab7', '#3f51b5', '#2196f3',
339	'#009688', '#1b5e20', '#33691e', '#827717', '#e65100', '#ff5722',
340	'#795548', '#607d8b',
341	];
342
343	const data = await plugins.hooks.fire('filter:user.iconBackgrounds', { iconBackgrounds: _iconBackgrounds });	3✔
344	iconBackgrounds = data.iconBackgrounds;	3✔
345	return iconBackgrounds;	3✔
346	};
347
348	User.getDefaultAvatar = function () {	8✔
349	if (!meta.config.defaultAvatar) {	92✔
350	return '';	90✔
351	}
352	return meta.config.defaultAvatar.startsWith('http') ? meta.config.defaultAvatar : relative_path + meta.config.defaultAvatar;	2✔
353	};
354
355	User.setUserField = async function (uid, field, value) {	8✔
356	await User.setUserFields(uid, { [field]: value });	547✔
357	};
358
359	User.setUserFields = async function (uid, data) {	8✔
360	await db.setObject(`user:${uid}`, data);	711✔
361	for (const [field, value] of Object.entries(data)) {	711✔
362	plugins.hooks.fire('action:user.set', { uid, field, value, type: 'set' });	887✔
363	}
364	};
365
366	User.incrementUserFieldBy = async function (uid, field, value) {	8✔
367	return await incrDecrUserFieldBy(uid, field, value, 'increment');	222✔
368	};
369
370	User.decrementUserFieldBy = async function (uid, field, value) {	8✔
371	return await incrDecrUserFieldBy(uid, field, -value, 'decrement');	17✔
372	};
373
374	async function incrDecrUserFieldBy(uid, field, value, type) {
375	const newValue = await db.incrObjectFieldBy(`user:${uid}`, field, value);	239✔
376	plugins.hooks.fire('action:user.set', { uid: uid, field: field, value: newValue, type: type });	239✔
377	return newValue;	239✔
378	}
379	};

CMU-313 / NodeBB / 10692281656

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