10692483720

Committed 03 Sep 2024 11:56PM UTC coverage: 82.679% (+0.008%) from 82.671%

Build # 10692483720

Build Type

Pull #441

github

Committed by

web-flow

Commit Message

Merge ee511dd86 into e7cfda55c

Pull Request Pull Request #441: Refactoring code in public/src/admin/admin.js

Run Details

9965 of 13474 branches covered (73.96%)

Branch coverage included in aggregate %.

0 of 4 new or added lines in 1 file covered. (0.0%)

2 existing lines in 2 files now uncovered.

22327 of 25583 relevant lines covered (87.27%)

1632.73 hits per line

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

79.27

/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']);

        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 (notification.image === 'brand:logo' || !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';
                        }
                        let set;
                        if (differentiator === 0 && differentiators.length === 1) {
                                set = isolated;
                        } else {
                                set = isolated.filter(n => n.mergeId === (`${mergeId}|${differentiator}`));
                        }

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

CMU-313 / NodeBB / 10692483720

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