11506334754

Committed 24 Oct 2024 07:43PM UTC coverage: 82.678% (+0.007%) from 82.671%

Build # 11506334754

Build Type

Pull #560

github

Committed by

web-flow

Commit Message

Merge d06386fd1 into e7cfda55c

Pull Request Pull Request #560: Fixed complexity issues of src/notifications.js

Run Details

9964 of 13470 branches covered (73.97%)

Branch coverage included in aggregate %.

8 of 12 new or added lines in 1 file covered. (66.67%)

1 existing line in 1 file now uncovered.

22325 of 25584 relevant lines covered (87.26%)

1632.75 hits per line

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

80.69

/src/notifications.js

'use strict';


const async = require('async');
const winston = require('winston');
const cron = require('cron').CronJob;
const nconf = require('nconf');
const _ = require('lodash');

const db = require('./database');
const User = require('./user');
const posts = require('./posts');
const groups = require('./groups');
const meta = require('./meta');
const batch = require('./batch');
const plugins = require('./plugins');
const utils = require('./utils');
const emailer = require('./emailer');
const ttlCache = require('./cache/ttl');

const Notifications = module.exports;

// ttlcache for email-only chat notifications
const notificationCache = ttlCache({
        ttl: (meta.config.notificationSendDelay || 60) * 1000,
        noDisposeOnSet: true,
        dispose: sendEmail,
});

Notifications.baseTypes = [
        'notificationType_upvote',
        'notificationType_new-topic',
        'notificationType_new-topic-with-tag',
        'notificationType_new-topic-in-category',
        'notificationType_new-reply',
        'notificationType_post-edit',
        'notificationType_follow',
        'notificationType_new-chat',
        'notificationType_new-group-chat',
        'notificationType_new-public-chat',
        'notificationType_group-invite',
        'notificationType_group-leave',
        'notificationType_group-request-membership',
        'notificationType_new-reward',
];

Notifications.privilegedTypes = [
        'notificationType_new-register',
        'notificationType_post-queue',
        'notificationType_new-post-flag',
        'notificationType_new-user-flag',
];

const notificationPruneCutoff = 2592000000; // one month

const intFields = ['datetime', 'from', 'importance', 'tid', 'pid', 'roomId'];

Notifications.getAllNotificationTypes = async function () {
        const results = await plugins.hooks.fire('filter:user.notificationTypes', {
                types: Notifications.baseTypes.slice(),
                privilegedTypes: Notifications.privilegedTypes.slice(),
        });
        return results.types.concat(results.privilegedTypes);
};

Notifications.startJobs = function () {
        winston.verbose('[notifications.init] Registering jobs.');
        new cron('*/30 * * * *', Notifications.prune, null, true);
};

Notifications.get = async function (nid) {
        const notifications = await Notifications.getMultiple([nid]);
        return Array.isArray(notifications) && notifications.length ? notifications[0] : null;
};

Notifications.getMultiple = async function (nids) {
        if (!Array.isArray(nids) || !nids.length) {
                return [];
        }

        const keys = nids.map(nid => `notifications:${nid}`);
        const notifications = await db.getObjects(keys);

        const userKeys = notifications.map(n => n && n.from);
        const usersData = await User.getUsersFields(userKeys, ['username', 'userslug', 'picture']);
        function imageNotFound(image) {
                return (image === 'brand:logo' || !image);
        }
        notifications.forEach((notification, index) => {
                if (notification) {
                        intFields.forEach((field) => {
                                if (notification.hasOwnProperty(field)) {
                                        notification[field] = parseInt(notification[field], 10) || 0;
                                }
                        });
                        if (notification.path && !notification.path.startsWith('http')) {
                                notification.path = nconf.get('relative_path') + notification.path;
                        }
                        notification.datetimeISO = utils.toISOString(notification.datetime);

                        if (notification.bodyLong) {
                                notification.bodyLong = utils.stripHTMLTags(notification.bodyLong, ['img', 'p', 'a']);
                        }

                        notification.user = usersData[index];
                        if (notification.user && notification.from) {
                                notification.image = notification.user.picture || null;
                                if (notification.user.username === '[[global:guest]]') {
                                        notification.bodyShort = notification.bodyShort.replace(/([\s\S]*?),[\s\S]*?,([\s\S]*?)/, '$1, [[global:guest]], $2');
                                }
                        } else if (imageNotFound(notification.image)) {
                                notification.image = meta.config['brand:logo'] || `${nconf.get('relative_path')}/logo.png`;
                        }
                }
        });
        return notifications;
};

Notifications.filterExists = async function (nids) {
        const exists = await db.isSortedSetMembers('notifications', nids);
        return nids.filter((nid, idx) => exists[idx]);
};

Notifications.findRelated = async function (mergeIds, set) {
        mergeIds = mergeIds.filter(Boolean);
        if (!mergeIds.length) {
                return [];
        }
        // A related notification is one in a zset that has the same mergeId
        const nids = await db.getSortedSetRevRange(set, 0, -1);

        const keys = nids.map(nid => `notifications:${nid}`);
        const notificationData = await db.getObjectsFields(keys, ['mergeId']);
        const notificationMergeIds = notificationData.map(notifObj => String(notifObj.mergeId));
        const mergeSet = new Set(mergeIds.map(id => String(id)));
        return nids.filter((nid, idx) => mergeSet.has(notificationMergeIds[idx]));
};

Notifications.create = async function (data) {
        if (!data.nid) {
                throw new Error('[[error:no-notification-id]]');
        }
        data.importance = data.importance || 5;
        const oldNotif = await db.getObject(`notifications:${data.nid}`);
        if (
                oldNotif &&
                parseInt(oldNotif.pid, 10) === parseInt(data.pid, 10) &&
                parseInt(oldNotif.importance, 10) > parseInt(data.importance, 10)
        ) {
                return null;
        }
        const now = Date.now();
        data.datetime = now;
        const result = await plugins.hooks.fire('filter:notifications.create', {
                data: data,
        });
        if (!result.data) {
                return null;
        }
        await Promise.all([
                db.sortedSetAdd('notifications', now, data.nid),
                db.setObject(`notifications:${data.nid}`, data),
        ]);
        return data;
};

Notifications.push = async function (notification, uids) {
        if (!notification || !notification.nid) {
                return;
        }
        uids = Array.isArray(uids) ? _.uniq(uids) : [uids];
        if (!uids.length) {
                return;
        }

        setTimeout(() => {
                batch.processArray(uids, async (uids) => {
                        await pushToUids(uids, notification);
                }, { interval: 1000, batch: 500 }, (err) => {
                        if (err) {
                                winston.error(err.stack);
                        }
                });
        }, 500);
};

async function pushToUids(uids, notification) {
        async function sendNotification(uids) {
                if (!uids.length) {
                        return;
                }
                const cutoff = Date.now() - notificationPruneCutoff;
                const unreadKeys = uids.map(uid => `uid:${uid}:notifications:unread`);
                const readKeys = uids.map(uid => `uid:${uid}:notifications:read`);
                await Promise.all([
                        db.sortedSetsAdd(unreadKeys, notification.datetime, notification.nid),
                        db.sortedSetsRemove(readKeys, notification.nid),
                ]);
                await db.sortedSetsRemoveRangeByScore(unreadKeys.concat(readKeys), '-inf', cutoff);
                const websockets = require('./socket.io');
                if (websockets.server) {
                        await Promise.all(uids.map(async (uid) => {
                                await plugins.hooks.fire('filter:sockets.sendNewNoticationToUid', {
                                        uid,
                                        notification,
                                });
                                websockets.in(`uid_${uid}`).emit('event:new_notification', notification);
                        }));
                }
        }

        async function getUidsBySettings(uids) {
                const uidsToNotify = [];
                const uidsToEmail = [];
                const usersSettings = await User.getMultipleUserSettings(uids);
                usersSettings.forEach((userSettings) => {
                        const setting = userSettings[`notificationType_${notification.type}`] || 'notification';

                        if (setting === 'notification' || setting === 'notificationemail') {
                                uidsToNotify.push(userSettings.uid);
                        }

                        if (setting === 'email' || setting === 'notificationemail') {
                                uidsToEmail.push(userSettings.uid);
                        }
                });
                return { uidsToNotify: uidsToNotify, uidsToEmail: uidsToEmail };
        }

        // Remove uid from recipients list if they have blocked the user triggering the notification
        uids = await User.blocks.filterUids(notification.from, uids);
        const data = await plugins.hooks.fire('filter:notification.push', {
                notification,
                uids,
        });
        if (!data || !data.notification || !data.uids || !data.uids.length) {
                return;
        }

        notification = data.notification;
        let results = { uidsToNotify: data.uids, uidsToEmail: [] };
        if (notification.type) {
                results = await getUidsBySettings(data.uids);
        }
        await sendNotification(results.uidsToNotify);
        const delayNotificationTypes = ['new-chat', 'new-group-chat', 'new-public-chat'];
        if (delayNotificationTypes.includes(notification.type)) {
                const cacheKey = `${notification.mergeId}|${results.uidsToEmail.join(',')}`;
                if (notificationCache.has(cacheKey)) {
                        const payload = notificationCache.get(cacheKey);
                        notification.bodyLong = [payload.notification.bodyLong, notification.bodyLong].join('\n');
                }
                notificationCache.set(cacheKey, { uids: results.uidsToEmail, notification });
        } else {
                await sendEmail({ uids: results.uidsToEmail, notification });
        }

        plugins.hooks.fire('action:notification.pushed', {
                notification,
                uids: results.uidsToNotify,
                uidsNotified: results.uidsToNotify,
                uidsEmailed: results.uidsToEmail,
        });
}

async function sendEmail({ uids, notification }, mergeId, reason) {
        // Only act on cache item expiry
        if (reason && reason !== 'stale') {
                return;
        }

        // Update CTA messaging (as not all notification types need custom text)
        if (['new-reply', 'new-chat'].includes(notification.type)) {
                notification['cta-type'] = notification.type;
        }
        let body = notification.bodyLong || '';
        if (meta.config.removeEmailNotificationImages) {
                body = body.replace(/<img[^>]*>/, '');
        }
        body = posts.relativeToAbsolute(body, posts.urlRegex);
        body = posts.relativeToAbsolute(body, posts.imgRegex);
        let errorLogged = false;
        await async.eachLimit(uids, 3, async (uid) => {
                await emailer.send('notification', uid, {
                        path: notification.path,
                        notification_url: notification.path.startsWith('http') ? notification.path : nconf.get('url') + notification.path,
                        subject: utils.stripHTMLTags(notification.subject || '[[notifications:new-notification]]'),
                        intro: utils.stripHTMLTags(notification.bodyShort),
                        body: body,
                        notification: notification,
                        showUnsubscribe: true,
                }).catch((err) => {
                        if (!errorLogged) {
                                winston.error(`[emailer.send] ${err.stack}`);
                                errorLogged = true;
                        }
                });
        });
}

Notifications.pushGroup = async function (notification, groupName) {
        if (!notification) {
                return;
        }
        const members = await groups.getMembers(groupName, 0, -1);
        await Notifications.push(notification, members);
};

Notifications.pushGroups = async function (notification, groupNames) {
        if (!notification) {
                return;
        }
        let groupMembers = await groups.getMembersOfGroups(groupNames);
        groupMembers = _.uniq(_.flatten(groupMembers));
        await Notifications.push(notification, groupMembers);
};

Notifications.rescind = async function (nids) {
        nids = Array.isArray(nids) ? nids : [nids];
        await Promise.all([
                db.sortedSetRemove('notifications', nids),
                db.deleteAll(nids.map(nid => `notifications:${nid}`)),
        ]);
};

Notifications.markRead = async function (nid, uid) {
        if (parseInt(uid, 10) <= 0 || !nid) {
                return;
        }
        await Notifications.markReadMultiple([nid], uid);
};

Notifications.markUnread = async function (nid, uid) {
        if (!(parseInt(uid, 10) > 0) || !nid) {
                return;
        }
        const notification = await db.getObject(`notifications:${nid}`);
        if (!notification) {
                throw new Error('[[error:no-notification]]');
        }
        notification.datetime = notification.datetime || Date.now();

        await Promise.all([
                db.sortedSetRemove(`uid:${uid}:notifications:read`, nid),
                db.sortedSetAdd(`uid:${uid}:notifications:unread`, notification.datetime, nid),
        ]);
};

Notifications.markReadMultiple = async function (nids, uid) {
        nids = nids.filter(Boolean);
        if (!Array.isArray(nids) || !nids.length || !(parseInt(uid, 10) > 0)) {
                return;
        }

        let notificationKeys = nids.map(nid => `notifications:${nid}`);
        let mergeIds = await db.getObjectsFields(notificationKeys, ['mergeId']);
        // Isolate mergeIds and find related notifications
        mergeIds = _.uniq(mergeIds.map(set => set.mergeId));

        const relatedNids = await Notifications.findRelated(mergeIds, `uid:${uid}:notifications:unread`);
        notificationKeys = _.union(nids, relatedNids).map(nid => `notifications:${nid}`);

        let notificationData = await db.getObjectsFields(notificationKeys, ['nid', 'datetime']);
        notificationData = notificationData.filter(n => n && n.nid);

        nids = notificationData.map(n => n.nid);
        const datetimes = notificationData.map(n => (n && n.datetime) || Date.now());
        await Promise.all([
                db.sortedSetRemove(`uid:${uid}:notifications:unread`, nids),
                db.sortedSetAdd(`uid:${uid}:notifications:read`, datetimes, nids),
        ]);
};

Notifications.markAllRead = async function (uid) {
        const nids = await db.getSortedSetRevRange(`uid:${uid}:notifications:unread`, 0, 99);
        await Notifications.markReadMultiple(nids, uid);
};

Notifications.prune = async function () {
        const cutoffTime = Date.now() - notificationPruneCutoff;
        const nids = await db.getSortedSetRangeByScore('notifications', 0, 500, '-inf', cutoffTime);
        if (!nids.length) {
                return;
        }
        try {
                await Promise.all([
                        db.sortedSetRemove('notifications', nids),
                        db.deleteAll(nids.map(nid => `notifications:${nid}`)),
                ]);

                await batch.processSortedSet('users:joindate', async (uids) => {
                        const unread = uids.map(uid => `uid:${uid}:notifications:unread`);
                        const read = uids.map(uid => `uid:${uid}:notifications:read`);
                        await db.sortedSetsRemoveRangeByScore(unread.concat(read), '-inf', cutoffTime);
                }, { batch: 500, interval: 100 });
        } catch (err) {
                if (err) {
                        winston.error(`Encountered error pruning notifications\n${err.stack}`);
                }
        }
};

Notifications.merge = async function (notifications) {
        // When passed a set of notification objects, merge any that can be merged
        const mergeIds = [
                'notifications:upvoted-your-post-in',
                'notifications:user-started-following-you',
                'notifications:user-posted-to',
                'notifications:user-flagged-post-in',
                'notifications:user-flagged-user',
                'new-chat',
                'notifications:user-posted-in-public-room',
                'new-register',
                'post-queue',
        ];

        notifications = mergeIds.reduce((notifications, mergeId) => {
                const isolated = notifications.filter(n => n && n.hasOwnProperty('mergeId') && n.mergeId.split('|')[0] === mergeId);
                if (isolated.length <= 1) {
                        return notifications; // Nothing to merge
                }

                // Each isolated mergeId may have multiple differentiators, so process each separately
                const differentiators = isolated.reduce((cur, next) => {
                        const differentiator = next.mergeId.split('|')[1] || 0;
                        if (!cur.includes(differentiator)) {
                                cur.push(differentiator);
                        }

                        return cur;
                }, []);

                differentiators.forEach((differentiator) => {
                        function typeFromLength(items) {
                                if (items.length === 2) {
                                        return 'dual';
                                } else if (items.length === 3) {
                                        return 'triple';
                                }
                                return 'multiple';
                        }
                        function isSetIsolated(differentiator, length) {
                                if (differentiator === 0 || length === 1) {
                                        return isolated;
                                }
                                return isolated.filter(n => n.mergeId === (`${mergeId}|${differentiator}`));
                        }
                        const set = isSetIsolated(differentiator, differentiators.length);

                        const modifyIndex = notifications.indexOf(set[0]);
                        if (modifyIndex === -1 || set.length === 1) {
                                return notifications;
                        }
                        const notifObj = notifications[modifyIndex];
                        switch (mergeId) {
                                case 'new-chat': {
                                        const { roomId, roomName, type, user } = set[0];
                                        const isGroupChat = type === 'new-group-chat';
                                        notifObj.bodyShort = isGroupChat || (roomName !== `[[modules:chat.room-id, ${roomId}]]`) ?
                                                `[[notifications:new-messages-in, ${set.length}, ${roomName}]]` :
                                                `[[notifications:new-messages-from, ${set.length}, ${user.displayname}]]`;
                                        break;
                                }

                                case 'notifications:user-posted-in-public-room': {
                                        const usernames = _.uniq(set.map(notifObj => notifObj && notifObj.user && notifObj.user.displayname));
                                        if (usernames.length > 3) {
                                                notifObj.bodyShort = `[[${mergeId}-${typeFromLength(usernames)}, ${usernames.slice(0, 2).join(', ')}, ${usernames.length - 2}, ${notifObj.roomIcon}, ${notifObj.roomName}]]`;
                                        } else if (usernames.length > 1) {
                                                notifObj.bodyShort = `[[${mergeId}-${typeFromLength(usernames)}, ${usernames.join(', ')}, ${notifObj.roomIcon}, ${notifObj.roomName}]]`;
                                        }

                                        notifObj.path = set[set.length - 1].path;
                                        break;
                                }
                                case 'notifications:upvoted-your-post-in':
                                case 'notifications:user-started-following-you':
                                case 'notifications:user-posted-to':
                                case 'notifications:user-flagged-post-in':
                                case 'notifications:user-flagged-user': {
                                        const usernames = _.uniq(set.map(notifObj => notifObj && notifObj.user && notifObj.user.username));
                                        const numUsers = usernames.length;

                                        const title = utils.decodeHTMLEntities(notifications[modifyIndex].topicTitle || '');
                                        let titleEscaped = title.replace(/%/g, '&#37;').replace(/,/g, '&#44;');
                                        titleEscaped = titleEscaped ? (`, ${titleEscaped}`) : '';

                                        if (numUsers > 3) {
                                                notifications[modifyIndex].bodyShort = `[[${mergeId}-${typeFromLength(usernames)}, ${usernames.slice(0, 2).join(', ')}, ${numUsers - 2}${titleEscaped}]]`;
                                        } else if (numUsers > 1) {
                                                notifications[modifyIndex].bodyShort = `[[${mergeId}-${typeFromLength(usernames)}, ${usernames.join(', ')}${titleEscaped}]]`;
                                        }
                                        notifications[modifyIndex].path = set[set.length - 1].path;
                                } break;

                                case 'new-register':
                                        notifications[modifyIndex].bodyShort = `[[notifications:${mergeId}-multiple, ${set.length}]]`;
                                        break;
                        }

                        // Filter out duplicates
                        notifications = notifications.filter((notifObj, idx) => {
                                if (!notifObj || !notifObj.mergeId) {
                                        return true;
                                }

                                return !(notifObj.mergeId === (mergeId + (differentiator ? `|${differentiator}` : '')) && idx !== modifyIndex);
                        });
                });

                return notifications;
        }, notifications);

        const data = await plugins.hooks.fire('filter:notifications.merge', {
                notifications: notifications,
        });
        return data && data.notifications;
};

require('./promisify')(Notifications);

1	'use strict';
2
3
4	const async = require('async');	8✔
5	const winston = require('winston');	8✔
6	const cron = require('cron').CronJob;	8✔
7	const nconf = require('nconf');	8✔
8	const _ = require('lodash');	8✔
9
10	const db = require('./database');	8✔
11	const User = require('./user');	8✔
12	const posts = require('./posts');	8✔
13	const groups = require('./groups');	8✔
14	const meta = require('./meta');	8✔
15	const batch = require('./batch');	8✔
16	const plugins = require('./plugins');	8✔
17	const utils = require('./utils');	8✔
18	const emailer = require('./emailer');	8✔
19	const ttlCache = require('./cache/ttl');	8✔
20
21	const Notifications = module.exports;	8✔
22
23	// ttlcache for email-only chat notifications
24	const notificationCache = ttlCache({	8✔
25	ttl: (meta.config.notificationSendDelay \|\| 60) * 1000,	16✔
26	noDisposeOnSet: true,
27	dispose: sendEmail,
28	});
29
30	Notifications.baseTypes = [	8✔
31	'notificationType_upvote',
32	'notificationType_new-topic',
33	'notificationType_new-topic-with-tag',
34	'notificationType_new-topic-in-category',
35	'notificationType_new-reply',
36	'notificationType_post-edit',
37	'notificationType_follow',
38	'notificationType_new-chat',
39	'notificationType_new-group-chat',
40	'notificationType_new-public-chat',
41	'notificationType_group-invite',
42	'notificationType_group-leave',
43	'notificationType_group-request-membership',
44	'notificationType_new-reward',
45	];
46
47	Notifications.privilegedTypes = [	8✔
48	'notificationType_new-register',
49	'notificationType_post-queue',
50	'notificationType_new-post-flag',
51	'notificationType_new-user-flag',
52	];
53
54	const notificationPruneCutoff = 2592000000; // one month	8✔
55
56	const intFields = ['datetime', 'from', 'importance', 'tid', 'pid', 'roomId'];	8✔
57
58	Notifications.getAllNotificationTypes = async function () {	8✔
59	const results = await plugins.hooks.fire('filter:user.notificationTypes', {	2,683✔
60	types: Notifications.baseTypes.slice(),
61	privilegedTypes: Notifications.privilegedTypes.slice(),
62	});
63	return results.types.concat(results.privilegedTypes);	2,683✔
64	};
65
66	Notifications.startJobs = function () {	8✔
67	winston.verbose('[notifications.init] Registering jobs.');	1✔
68	new cron('/30 * * *', Notifications.prune, null, true);	1✔
69	};
70
71	Notifications.get = async function (nid) {	8✔
72	const notifications = await Notifications.getMultiple([nid]);	1✔
73	return Array.isArray(notifications) && notifications.length ? notifications[0] : null;	1!
74	};
75
76	Notifications.getMultiple = async function (nids) {	8✔
77	if (!Array.isArray(nids) \|\| !nids.length) {	12✔
78	return [];	1✔
79	}
80
81	const keys = nids.map(nid => `notifications:${nid}`);	19✔
82	const notifications = await db.getObjects(keys);	11✔
83
84	const userKeys = notifications.map(n => n && n.from);	19✔
85	const usersData = await User.getUsersFields(userKeys, ['username', 'userslug', 'picture']);	11✔
86	function imageNotFound(image) {
87	return (image === 'brand:logo' \|\| !image);	4✔
88	}
89	notifications.forEach((notification, index) => {	11✔
90	if (notification) {	19✔
91	intFields.forEach((field) => {	13✔
92	if (notification.hasOwnProperty(field)) {	78✔
93	notification[field] = parseInt(notification[field], 10) \|\| 0;	46!
94	}
95	});
96	if (notification.path && !notification.path.startsWith('http')) {	13!
97	notification.path = nconf.get('relative_path') + notification.path;	13✔
98	}
99	notification.datetimeISO = utils.toISOString(notification.datetime);	13✔
100
101	if (notification.bodyLong) {	13✔
102	notification.bodyLong = utils.stripHTMLTags(notification.bodyLong, ['img', 'p', 'a']);	5✔
103	}
104
105	notification.user = usersData[index];	13✔
106	if (notification.user && notification.from) {	13✔
107	notification.image = notification.user.picture \|\| null;	9✔
108	if (notification.user.username === '[[global:guest]]') {	9!
109	notification.bodyShort = notification.bodyShort.replace(/([\s\S]?),[\s\S]?,([\s\S]*?)/, '$1, [[global:guest]], $2');	×
110	}
111	} else if (imageNotFound(notification.image)) {	4!
112	notification.image = meta.config['brand:logo'] \|\| `${nconf.get('relative_path')}/logo.png`;	4✔
113	}
114	}
115	});
116	return notifications;	11✔
117	};
118
119	Notifications.filterExists = async function (nids) {	8✔
120	const exists = await db.isSortedSetMembers('notifications', nids);	48✔
121	return nids.filter((nid, idx) => exists[idx]);	57✔
122	};
123
124	Notifications.findRelated = async function (mergeIds, set) {	8✔
125	mergeIds = mergeIds.filter(Boolean);	16✔
126	if (!mergeIds.length) {	16✔
127	return [];	2✔
128	}
129	// A related notification is one in a zset that has the same mergeId
130	const nids = await db.getSortedSetRevRange(set, 0, -1);	14✔
131
132	const keys = nids.map(nid => `notifications:${nid}`);	14✔
133	const notificationData = await db.getObjectsFields(keys, ['mergeId']);	14✔
134	const notificationMergeIds = notificationData.map(notifObj => String(notifObj.mergeId));	14✔
135	const mergeSet = new Set(mergeIds.map(id => String(id)));	14✔
136	return nids.filter((nid, idx) => mergeSet.has(notificationMergeIds[idx]));	14✔
137	};
138
139	Notifications.create = async function (data) {	8✔
140	if (!data.nid) {	104✔
141	throw new Error('[[error:no-notification-id]]');	1✔
142	}
143	data.importance = data.importance \|\| 5;	103✔
144	const oldNotif = await db.getObject(`notifications:${data.nid}`);	103✔
145	if (	103✔
146	oldNotif &&	111✔
147	parseInt(oldNotif.pid, 10) === parseInt(data.pid, 10) &&
148	parseInt(oldNotif.importance, 10) > parseInt(data.importance, 10)
149	) {
150	return null;	1✔
151	}
152	const now = Date.now();	102✔
153	data.datetime = now;	102✔
154	const result = await plugins.hooks.fire('filter:notifications.create', {	102✔
155	data: data,
156	});
157	if (!result.data) {	102!
158	return null;	×
159	}
160	await Promise.all([	102✔
161	db.sortedSetAdd('notifications', now, data.nid),
162	db.setObject(`notifications:${data.nid}`, data),
163	]);
164	return data;	102✔
165	};
166
167	Notifications.push = async function (notification, uids) {	8✔
168	if (!notification \|\| !notification.nid) {	105✔
169	return;	2✔
170	}
171	uids = Array.isArray(uids) ? _.uniq(uids) : [uids];	103✔
172	if (!uids.length) {	103✔
173	return;	7✔
174	}
175
176	setTimeout(() => {	96✔
177	batch.processArray(uids, async (uids) => {	96✔
178	await pushToUids(uids, notification);	96✔
179	}, { interval: 1000, batch: 500 }, (err) => {
180	if (err) {	96!
181	winston.error(err.stack);	×
182	}
183	});
184	}, 500);
185	};
186
187	async function pushToUids(uids, notification) {
188	async function sendNotification(uids) {
189	if (!uids.length) {	96!
190	return;	×
191	}
192	const cutoff = Date.now() - notificationPruneCutoff;	96✔
193	const unreadKeys = uids.map(uid => `uid:${uid}:notifications:unread`);	123✔
194	const readKeys = uids.map(uid => `uid:${uid}:notifications:read`);	123✔
195	await Promise.all([	96✔
196	db.sortedSetsAdd(unreadKeys, notification.datetime, notification.nid),
197	db.sortedSetsRemove(readKeys, notification.nid),
198	]);
199	await db.sortedSetsRemoveRangeByScore(unreadKeys.concat(readKeys), '-inf', cutoff);	96✔
200	const websockets = require('./socket.io');	96✔
201	if (websockets.server) {	96!
202	await Promise.all(uids.map(async (uid) => {	96✔
203	await plugins.hooks.fire('filter:sockets.sendNewNoticationToUid', {	123✔
204	uid,
205	notification,
206	});
207	websockets.in(`uid_${uid}`).emit('event:new_notification', notification);	123✔
208	}));
209	}
210	}
211
212	async function getUidsBySettings(uids) {
213	const uidsToNotify = [];	63✔
214	const uidsToEmail = [];	63✔
215	const usersSettings = await User.getMultipleUserSettings(uids);	63✔
216	usersSettings.forEach((userSettings) => {	63✔
217	const setting = userSettings[`notificationType_${notification.type}`] \|\| 'notification';	90✔
218
219	if (setting === 'notification' \|\| setting === 'notificationemail') {	90!
220	uidsToNotify.push(userSettings.uid);	90✔
221	}
222
223	if (setting === 'email' \|\| setting === 'notificationemail') {	90!
224	uidsToEmail.push(userSettings.uid);	×
225	}
226	});
227	return { uidsToNotify: uidsToNotify, uidsToEmail: uidsToEmail };	63✔
228	}
229
230	// Remove uid from recipients list if they have blocked the user triggering the notification
231	uids = await User.blocks.filterUids(notification.from, uids);	96✔
232	const data = await plugins.hooks.fire('filter:notification.push', {	96✔
233	notification,
234	uids,
235	});
236	if (!data \|\| !data.notification \|\| !data.uids \|\| !data.uids.length) {	96!
237	return;	×
238	}
239
240	notification = data.notification;	96✔
241	let results = { uidsToNotify: data.uids, uidsToEmail: [] };	96✔
242	if (notification.type) {	96✔
243	results = await getUidsBySettings(data.uids);	63✔
244	}
245	await sendNotification(results.uidsToNotify);	96✔
246	const delayNotificationTypes = ['new-chat', 'new-group-chat', 'new-public-chat'];	96✔
247	if (delayNotificationTypes.includes(notification.type)) {	96✔
248	const cacheKey = `${notification.mergeId}\|${results.uidsToEmail.join(',')}`;	9✔
249	if (notificationCache.has(cacheKey)) {	9✔
250	const payload = notificationCache.get(cacheKey);	4✔
251	notification.bodyLong = [payload.notification.bodyLong, notification.bodyLong].join('\n');	4✔
252	}
253	notificationCache.set(cacheKey, { uids: results.uidsToEmail, notification });	9✔
254	} else {
255	await sendEmail({ uids: results.uidsToEmail, notification });	87✔
256	}
257
258	plugins.hooks.fire('action:notification.pushed', {	96✔
259	notification,
260	uids: results.uidsToNotify,
261	uidsNotified: results.uidsToNotify,
262	uidsEmailed: results.uidsToEmail,
263	});
264	}
265
266	async function sendEmail({ uids, notification }, mergeId, reason) {
267	// Only act on cache item expiry
268	if (reason && reason !== 'stale') {	92✔
269	return;	4✔
270	}
271
272	// Update CTA messaging (as not all notification types need custom text)
273	if (['new-reply', 'new-chat'].includes(notification.type)) {	88✔
274	notification['cta-type'] = notification.type;	14✔
275	}
276	let body = notification.bodyLong \|\| '';	88✔
277	if (meta.config.removeEmailNotificationImages) {	88!
278	body = body.replace(/<img[^>]*>/, '');	×
279	}
280	body = posts.relativeToAbsolute(body, posts.urlRegex);	88✔
281	body = posts.relativeToAbsolute(body, posts.imgRegex);	88✔
282	let errorLogged = false;	88✔
283	await async.eachLimit(uids, 3, async (uid) => {	88✔
284	await emailer.send('notification', uid, {	×
285	path: notification.path,
286	notification_url: notification.path.startsWith('http') ? notification.path : nconf.get('url') + notification.path,	×
287	subject: utils.stripHTMLTags(notification.subject \|\| '[[notifications:new-notification]]'),	×
288	intro: utils.stripHTMLTags(notification.bodyShort),
289	body: body,
290	notification: notification,
291	showUnsubscribe: true,
292	}).catch((err) => {
293	if (!errorLogged) {	×
294	winston.error(`[emailer.send] ${err.stack}`);	×
295	errorLogged = true;	×
296	}
297	});
298	});
299	}
300
301	Notifications.pushGroup = async function (notification, groupName) {	8✔
302	if (!notification) {	5!
303	return;	×
304	}
305	const members = await groups.getMembers(groupName, 0, -1);	5✔
306	await Notifications.push(notification, members);	5✔
307	};
308
309	Notifications.pushGroups = async function (notification, groupNames) {	8✔
310	if (!notification) {	1!
311	return;	×
312	}
313	let groupMembers = await groups.getMembersOfGroups(groupNames);	1✔
314	groupMembers = _.uniq(_.flatten(groupMembers));	1✔
315	await Notifications.push(notification, groupMembers);	1✔
316	};
317
318	Notifications.rescind = async function (nids) {	8✔
319	nids = Array.isArray(nids) ? nids : [nids];	24✔
320	await Promise.all([	24✔
321	db.sortedSetRemove('notifications', nids),
322	db.deleteAll(nids.map(nid => `notifications:${nid}`)),	21✔
323	]);
324	};
325
326	Notifications.markRead = async function (nid, uid) {	8✔
327	if (parseInt(uid, 10) <= 0 \|\| !nid) {	15✔
328	return;	2✔
329	}
330	await Notifications.markReadMultiple([nid], uid);	13✔
331	};
332
333	Notifications.markUnread = async function (nid, uid) {	8✔
334	if (!(parseInt(uid, 10) > 0) \|\| !nid) {	4✔
335	return;	2✔
336	}
337	const notification = await db.getObject(`notifications:${nid}`);	2✔
338	if (!notification) {	2✔
339	throw new Error('[[error:no-notification]]');	1✔
340	}
341	notification.datetime = notification.datetime \|\| Date.now();	1!
342
343	await Promise.all([	1✔
344	db.sortedSetRemove(`uid:${uid}:notifications:read`, nid),
345	db.sortedSetAdd(`uid:${uid}:notifications:unread`, notification.datetime, nid),
346	]);
347	};
348
349	Notifications.markReadMultiple = async function (nids, uid) {	8✔
350	nids = nids.filter(Boolean);	30✔
351	if (!Array.isArray(nids) \|\| !nids.length \|\| !(parseInt(uid, 10) > 0)) {	30✔
352	return;	14✔
353	}
354
355	let notificationKeys = nids.map(nid => `notifications:${nid}`);	18✔
356	let mergeIds = await db.getObjectsFields(notificationKeys, ['mergeId']);	16✔
357	// Isolate mergeIds and find related notifications
358	mergeIds = _.uniq(mergeIds.map(set => set.mergeId));	18✔
359
360	const relatedNids = await Notifications.findRelated(mergeIds, `uid:${uid}:notifications:unread`);	16✔
361	notificationKeys = _.union(nids, relatedNids).map(nid => `notifications:${nid}`);	18✔
362
363	let notificationData = await db.getObjectsFields(notificationKeys, ['nid', 'datetime']);	16✔
364	notificationData = notificationData.filter(n => n && n.nid);	18✔
365
366	nids = notificationData.map(n => n.nid);	16✔
367	const datetimes = notificationData.map(n => (n && n.datetime) \|\| Date.now());	16!
368	await Promise.all([	16✔
369	db.sortedSetRemove(`uid:${uid}:notifications:unread`, nids),
370	db.sortedSetAdd(`uid:${uid}:notifications:read`, datetimes, nids),
371	]);
372	};
373
374	Notifications.markAllRead = async function (uid) {	8✔
375	const nids = await db.getSortedSetRevRange(`uid:${uid}:notifications:unread`, 0, 99);	2✔
376	await Notifications.markReadMultiple(nids, uid);	2✔
377	};
378
379	Notifications.prune = async function () {	8✔
380	const cutoffTime = Date.now() - notificationPruneCutoff;	2✔
381	const nids = await db.getSortedSetRangeByScore('notifications', 0, 500, '-inf', cutoffTime);	2✔
382	if (!nids.length) {	2✔
383	return;	1✔
384	}
385	try {	1✔
386	await Promise.all([	1✔
387	db.sortedSetRemove('notifications', nids),
388	db.deleteAll(nids.map(nid => `notifications:${nid}`)),	1✔
389	]);
390
391	await batch.processSortedSet('users:joindate', async (uids) => {	1✔
392	const unread = uids.map(uid => `uid:${uid}:notifications:unread`);	3✔
393	const read = uids.map(uid => `uid:${uid}:notifications:read`);	3✔
394	await db.sortedSetsRemoveRangeByScore(unread.concat(read), '-inf', cutoffTime);	1✔
395	}, { batch: 500, interval: 100 });
396	} catch (err) {
397	if (err) {	×
398	winston.error(`Encountered error pruning notifications\n${err.stack}`);	×
399	}
400	}
401	};
402
403	Notifications.merge = async function (notifications) {	8✔
404	// When passed a set of notification objects, merge any that can be merged
405	const mergeIds = [	9✔
406	'notifications:upvoted-your-post-in',
407	'notifications:user-started-following-you',
408	'notifications:user-posted-to',
409	'notifications:user-flagged-post-in',
410	'notifications:user-flagged-user',
411	'new-chat',
412	'notifications:user-posted-in-public-room',
413	'new-register',
414	'post-queue',
415	];
416
417	notifications = mergeIds.reduce((notifications, mergeId) => {	9✔
418	const isolated = notifications.filter(n => n && n.hasOwnProperty('mergeId') && n.mergeId.split('\|')[0] === mergeId);	102✔
419	if (isolated.length <= 1) {	81✔
420	return notifications; // Nothing to merge	79✔
421	}
422
423	// Each isolated mergeId may have multiple differentiators, so process each separately
424	const differentiators = isolated.reduce((cur, next) => {	2✔
425	const differentiator = next.mergeId.split('\|')[1] \|\| 0;	4!
426	if (!cur.includes(differentiator)) {	4✔
427	cur.push(differentiator);	3✔
428	}
429
430	return cur;	4✔
431	}, []);
432
433	differentiators.forEach((differentiator) => {	2✔
434	function typeFromLength(items) {
435	if (items.length === 2) {	×
436	return 'dual';	×
437	} else if (items.length === 3) {	×
438	return 'triple';	×
439	}
440	return 'multiple';	×
441	}
442	function isSetIsolated(differentiator, length) {
443	if (differentiator === 0 \|\| length === 1) {	3✔
444	return isolated;	1✔
445	}
446	return isolated.filter(n => n.mergeId === (`${mergeId}\|${differentiator}`));	4✔
447	}
448	const set = isSetIsolated(differentiator, differentiators.length);	3✔
449
450	const modifyIndex = notifications.indexOf(set[0]);	3✔
451	if (modifyIndex === -1 \|\| set.length === 1) {	3✔
452	return notifications;	2✔
453	}
454	const notifObj = notifications[modifyIndex];	1✔
455	switch (mergeId) {	1!
456	case 'new-chat': {
457	const { roomId, roomName, type, user } = set[0];	×
458	const isGroupChat = type === 'new-group-chat';	×
459	notifObj.bodyShort = isGroupChat \|\| (roomName !== `[[modules:chat.room-id, ${roomId}]]`) ?	×
460	`[[notifications:new-messages-in, ${set.length}, ${roomName}]]` :
461	`[[notifications:new-messages-from, ${set.length}, ${user.displayname}]]`;
462	break;	×
463	}
464
465	case 'notifications:user-posted-in-public-room': {
466	const usernames = _.uniq(set.map(notifObj => notifObj && notifObj.user && notifObj.user.displayname));	×
NEW 467	if (usernames.length > 3) {	×
468	notifObj.bodyShort = `[[${mergeId}-${typeFromLength(usernames)}, ${usernames.slice(0, 2).join(', ')}, ${usernames.length - 2}, ${notifObj.roomIcon}, ${notifObj.roomName}]]`;	×
NEW 469	} else if (usernames.length > 1) {	×
NEW 470	notifObj.bodyShort = `[[${mergeId}-${typeFromLength(usernames)}, ${usernames.join(', ')}, ${notifObj.roomIcon}, ${notifObj.roomName}]]`;	×
471	}
472
473	notifObj.path = set[set.length - 1].path;	×
474	break;	×
475	}
476	case 'notifications:upvoted-your-post-in':
477	case 'notifications:user-started-following-you':
478	case 'notifications:user-posted-to':
479	case 'notifications:user-flagged-post-in':
480	case 'notifications:user-flagged-user': {
481	const usernames = _.uniq(set.map(notifObj => notifObj && notifObj.user && notifObj.user.username));	2✔
482	const numUsers = usernames.length;	1✔
483
484	const title = utils.decodeHTMLEntities(notifications[modifyIndex].topicTitle \|\| '');	1!
485	let titleEscaped = title.replace(/%/g, '%').replace(/,/g, ',');	1✔
486	titleEscaped = titleEscaped ? (`, ${titleEscaped}`) : '';	1!
487
488	if (numUsers > 3) {	1!
489	notifications[modifyIndex].bodyShort = `[[${mergeId}-${typeFromLength(usernames)}, ${usernames.slice(0, 2).join(', ')}, ${numUsers - 2}${titleEscaped}]]`;	×
490	} else if (numUsers > 1) {	1!
NEW 491	notifications[modifyIndex].bodyShort = `[[${mergeId}-${typeFromLength(usernames)}, ${usernames.join(', ')}${titleEscaped}]]`;	×
492	}
493	notifications[modifyIndex].path = set[set.length - 1].path;	1✔
494	} break;	1✔
495
496	case 'new-register':
497	notifications[modifyIndex].bodyShort = `[[notifications:${mergeId}-multiple, ${set.length}]]`;	×
498	break;	×
499	}
500
501	// Filter out duplicates
502	notifications = notifications.filter((notifObj, idx) => {	1✔
503	if (!notifObj \|\| !notifObj.mergeId) {	2!
504	return true;	×
505	}
506
507	return !(notifObj.mergeId === (mergeId + (differentiator ? `\|${differentiator}` : '')) && idx !== modifyIndex);	2!
508	});
509	});
510
511	return notifications;	2✔
512	}, notifications);
513
514	const data = await plugins.hooks.fire('filter:notifications.merge', {	9✔
515	notifications: notifications,
516	});
517	return data && data.notifications;	9✔
518	};
519
520	require('./promisify')(Notifications);	8✔

CMU-313 / NodeBB / 11506334754

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