6721588067

Committed 01 Nov 2023 03:21PM UTC coverage: 85.029% (+0.1%) from 84.913%

Build # 6721588067

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #78 from CMU-17313Q/Jupyter_notebook

add jupyter notebook and model and test data

Run Details

10244 of 13289 branches covered (0.0%)

Branch coverage included in aggregate %.

22647 of 25393 relevant lines covered (89.19%)

3101.72 hits per line

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

82.91

/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 Notifications = module.exports;

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

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

const notificationPruneCutoff = 2592000000; // one month

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) {
            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.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);
            }
        });
    }, 1000);
};

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) {
            uids.forEach((uid) => {
                websockets.in(`uid_${uid}`).emit('event:new_notification', notification);
            });
        }
    }

    async function sendEmail(uids) {
        // 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;
                }
            });
        });
    }

    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: notification, uids: 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 Promise.all([
        sendNotification(results.uidsToNotify),
        sendEmail(results.uidsToEmail),
    ]);
    plugins.hooks.fire('action:notification.pushed', {
        notification: notification,
        uids: results.uidsToNotify,
        uidsNotified: results.uidsToNotify,
        uidsEmailed: results.uidsToEmail,
    });
}

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_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) => {
            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;
            }

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

CMU-17313Q / fall23-nodebb-6-bits / 6721588067

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