4127173470

Build Type

push

github

Committed by GitHub

Commit Message

Fixes incorrect field access (#184)

Run Details

10210 of 13255 branches covered (77.03%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

3 existing lines in 2 files now uncovered.

22598 of 25350 relevant lines covered (89.14%)

3099.68 hits per line

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

92.05

/src/groups/join.js

'use strict';

const winston = require('winston');

const db = require('../database');
const user = require('../user');
const plugins = require('../plugins');
const cache = require('../cache');

module.exports = function (Groups) {
    Groups.join = async function (groupNames, uid) {
        if (!groupNames) {
            throw new Error('[[error:invalid-data]]');
        }
        if (Array.isArray(groupNames) && !groupNames.length) {
            return;
        }
        if (!Array.isArray(groupNames)) {
            groupNames = [groupNames];
        }

        if (!uid) {
            throw new Error('[[error:invalid-uid]]');
        }

        const [isMembers, exists, isAdmin] = await Promise.all([
            Groups.isMemberOfGroups(uid, groupNames),
            Groups.exists(groupNames),
            user.isAdministrator(uid),
        ]);

        const groupsToCreate = groupNames.filter((groupName, index) => groupName && !exists[index]);
        const groupsToJoin = groupNames.filter((groupName, index) => !isMembers[index]);

        if (!groupsToJoin.length) {
            return;
        }
        await createNonExistingGroups(groupsToCreate);

        const promises = [
            db.sortedSetsAdd(groupsToJoin.map(groupName => `group:${groupName}:members`), Date.now(), uid),
            db.incrObjectField(groupsToJoin.map(groupName => `group:${groupName}`), 'memberCount'),
        ];
        if (isAdmin) {
            promises.push(db.setsAdd(groupsToJoin.map(groupName => `group:${groupName}:owners`), uid));
        }

        await Promise.all(promises);

        Groups.clearCache(uid, groupsToJoin);
        cache.del(groupsToJoin.map(name => `group:${name}:members`));

        const groupData = await Groups.getGroupsFields(groupsToJoin, ['name', 'hidden', 'memberCount']);
        const visibleGroups = groupData.filter(groupData => groupData && !groupData.hidden);

        if (visibleGroups.length) {
            await db.sortedSetAdd(
                'groups:visible:memberCount',
                visibleGroups.map(groupData => groupData.memberCount),
                visibleGroups.map(groupData => groupData.name)
            );
        }

        await setGroupTitleIfNotSet(groupsToJoin, uid);

        plugins.hooks.fire('action:group.join', {
            groupNames: groupsToJoin,
            uid: uid,
        });
    };

    async function createNonExistingGroups(groupsToCreate) {
        if (!groupsToCreate.length) {
            return;
        }

        for (const groupName of groupsToCreate) {
            try {
                // eslint-disable-next-line no-await-in-loop
                await Groups.create({
                    name: groupName,
                    hidden: 1,
                });
            } catch (err) {
                if (err && err.message !== '[[error:group-already-exists]]') {
                    winston.error(`[groups.join] Could not create new hidden group (${groupName})\n${err.stack}`);
                    throw err;
                }
            }
        }
    }

    async function setGroupTitleIfNotSet(groupNames, uid) {
        const ignore = ['registered-users', 'verified-users', 'unverified-users', Groups.BANNED_USERS];
        groupNames = groupNames.filter(
            groupName => !ignore.includes(groupName) && !Groups.isPrivilegeGroup(groupName)
        );
        if (!groupNames.length) {
            return;
        }

        const currentTitle = await db.getObjectField(`user:${uid}`, 'groupTitle');
        if (currentTitle || currentTitle === '') {
            return;
        }

        await user.setUserField(uid, 'groupTitle', JSON.stringify(groupNames));
    }
};

1	'use strict';
2
3	const winston = require('winston');	20✔
4
5	const db = require('../database');	20✔
6	const user = require('../user');	20✔
7	const plugins = require('../plugins');	20✔
8	const cache = require('../cache');	20✔
9
10	module.exports = function (Groups) {	20✔
11	Groups.join = async function (groupNames, uid) {	20✔
12	if (!groupNames) {	3,884✔
13	throw new Error('[[error:invalid-data]]');	12✔
14	}
15	if (Array.isArray(groupNames) && !groupNames.length) {	3,872✔
16	return;	108✔
17	}
18	if (!Array.isArray(groupNames)) {	3,764✔
19	groupNames = [groupNames];	500✔
20	}
21
22	if (!uid) {	3,764✔
23	throw new Error('[[error:invalid-uid]]');	12✔
24	}
25
26	const [isMembers, exists, isAdmin] = await Promise.all([	3,752✔
27	Groups.isMemberOfGroups(uid, groupNames),
28	Groups.exists(groupNames),
29	user.isAdministrator(uid),
30	]);
31
32	const groupsToCreate = groupNames.filter((groupName, index) => groupName && !exists[index]);	21,088✔
33	const groupsToJoin = groupNames.filter((groupName, index) => !isMembers[index]);	21,088✔
34
35	if (!groupsToJoin.length) {	3,752✔
36	return;	96✔
37	}
38	await createNonExistingGroups(groupsToCreate);	3,656✔
39
40	const promises = [	3,656✔
41	db.sortedSetsAdd(groupsToJoin.map(groupName => `group:${groupName}:members`), Date.now(), uid),	20,964✔
42	db.incrObjectField(groupsToJoin.map(groupName => `group:${groupName}`), 'memberCount'),	20,964✔
43	];
44	if (isAdmin) {	3,656✔
45	promises.push(db.setsAdd(groupsToJoin.map(groupName => `group:${groupName}:owners`), uid));	32✔
46	}
47
48	await Promise.all(promises);	3,656✔
49
50	Groups.clearCache(uid, groupsToJoin);	3,656✔
51	cache.del(groupsToJoin.map(name => `group:${name}:members`));	20,964✔
52
53	const groupData = await Groups.getGroupsFields(groupsToJoin, ['name', 'hidden', 'memberCount']);	3,656✔
54	const visibleGroups = groupData.filter(groupData => groupData && !groupData.hidden);	20,964✔
55
56	if (visibleGroups.length) {	3,656✔
57	await db.sortedSetAdd(	92✔
58	'groups:visible:memberCount',
59	visibleGroups.map(groupData => groupData.memberCount),	96✔
60	visibleGroups.map(groupData => groupData.name)	96✔
61	);
62	}
63
64	await setGroupTitleIfNotSet(groupsToJoin, uid);	3,656✔
65
66	plugins.hooks.fire('action:group.join', {	3,656✔
67	groupNames: groupsToJoin,
68	uid: uid,
69	});
70	};
71
72	async function createNonExistingGroups(groupsToCreate) {
73	if (!groupsToCreate.length) {	3,656✔
74	return;	2,444✔
75	}
76
77	for (const groupName of groupsToCreate) {	1,212✔
78	try {	7,444✔
79	// eslint-disable-next-line no-await-in-loop
80	await Groups.create({	7,444✔
81	name: groupName,
82	hidden: 1,
83	});
84	} catch (err) {
UNCOV 85	if (err && err.message !== '[[error:group-already-exists]]') {	×
86	winston.error(`[groups.join] Could not create new hidden group (${groupName})\n${err.stack}`);	×
87	throw err;	×
88	}
89	}
90	}
91	}
92
93	async function setGroupTitleIfNotSet(groupNames, uid) {
94	const ignore = ['registered-users', 'verified-users', 'unverified-users', Groups.BANNED_USERS];	3,656✔
95	groupNames = groupNames.filter(	3,656✔
96	groupName => !ignore.includes(groupName) && !Groups.isPrivilegeGroup(groupName)	20,964✔
97	);
98	if (!groupNames.length) {	3,656✔
99	return;	3,380✔
100	}
101
102	const currentTitle = await db.getObjectField(`user:${uid}`, 'groupTitle');	276✔
103	if (currentTitle \|\| currentTitle === '') {	276✔
104	return;	48✔
105	}
106
107	await user.setUserField(uid, 'groupTitle', JSON.stringify(groupNames));	228✔
108	}
109	};

CMU-313 / NodeBB / 4127173470

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