Add Notifications collection and add/modify APIs to add notification view functionality

constants.js

@@ -62,6 +62,7 @@ const CONSTANTS = {
         'deletePosts'
     ],
     MAX_ACCOUNT_FOLLOW_REQUESTS_PER_API_CALL: 10,
+    MAX_NOTIFICATIONS_PER_API_CALL: 10, //Used in temp/getnotifications
     VOTED_USERS_API_ALLOWED_POST_FORMATS: ['Image', 'Poll', 'Thread'],
     VOTED_USERS_MAX_USERS_TO_SEND_PER_API_CALL: 10,
     VOTED_USERS_API_ALLOWED_VOTE_TYPES: ["Up", "Down"],

controllers/Temp.js

@@ -12,6 +12,7 @@ const RefreshToken = require('../models/RefreshToken');
 const Message = require('../models/Message');
 const Comment = require('../models/Comment');
 const CategoryMember = require('../models/CategoryMember');
+const Notification = require('../models/Notification');
 
 const HTTPWTLibrary = require('../libraries/HTTPWT');
 const CONSTANTS = require('../constants');
@@ -51,6 +52,9 @@ const categoryHelper = new CategoryLibrary();
 const UUIDLibrary = require('../libraries/UUID.js');
 const uuidHelper = new UUIDLibrary();
 
+const NotificationLibrary = require('../libraries/Notifications.js');
+const notificationHelper = new NotificationLibrary();
+
 const bcrypt = require('bcrypt')
 const mongoose = require('mongoose')
 
@@ -6703,6 +6707,123 @@ class TempController {
         })
     }
 
+    static #clearnotifications = (userId) => {
+        return new Promise(resolve => {
+            if (typeof userId !== 'string') {
+                return resolve(HTTPWTHandler.badInput(`userId must be a string. Provided type: ${typeof userId}`))
+            }
+
+            if (!mongoose.isObjectIdOrHexString(userId)) {
+                return resolve(HTTPWTHandler.badInput('userId must be an ObjectId.'))
+            }
+
+            User.findOne({_id: {$eq: userId}}).lean().then(userFound => {
+                if (!userFound) return resolve(HTTPWTHandler.notFound('Could not find user with provided userId.'))
+
+                Notification.deleteMany({userId: {$eq: userId}}).then(() => {
+                    return resolve(HTTPWTHandler.OK('Successfully deleted all notifications.'))
+                }).catch(error => {
+                    console.error('An error occurred while deleting all notifications with userId:', userId, '. The error was:', error)
+                    return resolve(HTTPWTHandler.serverError('An error occurred while deleting all notifications. Please try again.'))
+                })
+            }).catch(error => {
+                console.error('An error occurred while finding one user with id:', userId, '. The error was:', error);
+                return resolve(HTTPWTHandler.serverError('An error occurred while finding user. Please try again.'))
+            })
+        })
+    }
+
+    static #deletenotification = (userId, notificationId) => {
+        return new Promise(resolve => {
+            if (typeof userId !== 'string') {
+                return resolve(HTTPWTHandler.badInput(`userId must be a string. Provided type: ${typeof userId}`));
+            }
+
+            if (!mongoose.isObjectIdOrHexString(userId)) {
+                return resolve(HTTPWTHandler.badInput('userId must be an ObjectId.'))
+            }
+
+            if (typeof notificationId !== 'string') {
+                return resolve(HTTPWTHandler.badInput(`notificationId must be a string. Provided type: ${typeof notificationId}`))
+            }
+
+            if (!mongoose.isObjectIdOrHexString(notificationId)) {
+                return resolve(HTTPWTHandler.badInput('notificationId must be an ObjectId.'))
+            }
+
+            User.findOne({_id: {$eq: userId}}).lean().then(userFound => {
+                if (!userFound) return resolve(HTTPWTHandler.notFound('Could not find user with provided userId.'))
+
+                Notification.findOne({_id: {$eq: notificationId}}).then(notificationFound => {
+                    if (!notificationFound) return resolve(HTTPWTHandler.notFound('Could not find notification.'))
+
+                    if (String(notificationFound.userId) !== userId) return resolve(HTTPWTHandler.forbidden('You must be the notification owner to delete this notification.'))
+
+                    Notification.deleteOne({_id: {$eq: notificationId}}).then(() => {
+                        return resolve(HTTPWTHandler.OK('Successfully deleted notification'))
+                    }).catch(error => {
+                        console.error('An error occurred while deleting one notification with id:', notificationId, '. The error was:', error)
+                        return resolve(HTTPWTHandler.serverError('An error occurred while deleting notification. Please try again.'))
+                    })
+                })
+            }).catch(error => {
+                console.error('An error occurred while finding one user with id:', userId, '. The error was:', error)
+                return resolve(HTTPWTHandler.serverError('An error occurred while finding user. Please try again.'))
+            })
+        })
+    }
+
+    static #getnotifications = (userId, lastNotificationId) => {
+        return new Promise(resolve => {
+            if (typeof userId !== 'string') {
+                return resolve(HTTPWTHandler.badInput(`userId must be a string. Provided type: ${typeof userId}`))
+            }
+
+            if (!mongoose.isObjectIdOrHexString(userId)) {
+                return resolve(HTTPWTHandler.badInput('userId must be an ObjectId.'))
+            }
+
+            if (typeof lastNotificationId !== 'string' && lastNotificationId !== undefined) {
+                return resolve(HTTPWTHandler.badInput(`lastNotificationId must be a string or undefined. Provided type: ${typeof lastNotificationId}`))
+            }
+
+            if (typeof lastNotificationId === 'string' && !mongoose.isObjectIdOrHexString(lastNotificationId)) {
+                return resolve(HTTPWTHandler.badInput('lastNotificationId must be an ObjectId or undefined.'))
+            }
+
+            User.findOne({_id: {$eq: userId}}).lean().then(userFound => {
+                if (!userFound) return resolve(HTTPWTHandler.notFound('Could not find user with provided userId.'))
+
+                const notificationQuery = {
+                    userId: {$eq: userId}
+                }
+
+                if (typeof lastNotificationId === 'string') {
+                    notificationQuery._id = {$lt: lastNotificationId}
+                }
+
+                Notification.find(notificationQuery).sort({_id: -1}).limit(CONSTANTS.MAX_NOTIFICATIONS_PER_API_CALL).lean().then(notifications => {
+                    if (notifications.length < 1) return resolve(HTTPWTHandler.OK('No notifications could be found', {notifications: [], noMoreNotifications: true}))
+
+                    const notificationData = notificationHelper.returnNotificationDataToSend(notifications);
+
+                    const toSend = {
+                        notifications: notificationData,
+                        noMoreNotifications: notifications.length < CONSTANTS.MAX_NOTIFICATIONS_PER_API_CALL
+                    }
+
+                    return resolve(HTTPWTHandler.OK('Found notifications', toSend));
+                }).catch(error => {
+                    console.error('An error occurred while finding notifications with database query:', notificationQuery, '. The error was:', error)
+                    return resolve(HTTPWTHandler.serverError('An error occurred while finding notifications. Please try again.'))
+                })
+            }).catch(error => {
+                console.error('An error occurred while finding one user with id:', userId, '. The error was:', error)
+                return resolve(HTTPWTHandler.serverError('An error occurred while finding user. Please try again.'))
+            })
+        })
+    }
+
     static sendnotificationkey = async (userId, notificationKey, refreshTokenId) => {
         return await this.#sendnotificationkey(userId, notificationKey, refreshTokenId)
     }
@@ -7038,6 +7159,18 @@ class TempController {
     static getpollvoteusers = async (userId, pollId, pollOption, lastItemId) => {
         return await this.#getpollvoteusers(userId, pollId, pollOption, lastItemId)
     }
+
+    static clearnotifications = async (userId) => {
+        return await this.#clearnotifications(userId);
+    }
+
+    static deletenotification = async (userId, notificationId) => {
+        return await this.#deletenotification(userId, notificationId);
+    }
+
+    static getnotifications = async (userId, lastNotificationId) => {
+        return await this.#getnotifications(userId, lastNotificationId);
+    }
 }
 
 module.exports = TempController;

libraries/Notifications.js

@@ -0,0 +1,11 @@
+class Notifications {
+    returnNotificationDataToSend(rawNotificationData) {
+        return rawNotificationData.map(notification => {
+            delete notification.userId;
+            notification._id = String(notification._id)
+            return notification;
+        })
+    }
+}
+
+module.exports = Notifications;

models/Notification.js

@@ -0,0 +1,15 @@
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+const NotificationSchema = new Schema({
+	userId: mongoose.Types.ObjectId,
+	profilePublicId: String,
+	postId: mongoose.Types.ObjectId,
+	postFormat: String,
+	dateCreated: Date,
+	text: String
+})
+
+const Notification = mongoose.model('Notification', NotificationSchema);
+
+module.exports = Notification;

routes/Temp.js

@@ -749,6 +749,33 @@ const rateLimiters = {
         skipFailedRequests: true,
         keyGenerator: (req, res) => req.tokenData //Use req.tokenData (account _id in MongoDB) to identify clients and rate limit
     }),
+    '/clearnotifications': rateLimit({
+        windowMs: 1000 * 60, //1 minute
+        max: 5,
+        standardHeaders: false,
+        legacyHeaders: false,
+        message: {status: "FAILED", message: "You have cleared your notifications too many times in the last minute. Please try again in 60 seconds."},
+        skipFailedRequests: true,
+        keyGenerator: (req, res) => req.tokenData //Use req.tokenData (account _id in MongoDB) to identify clients and rate limit
+    }),
+    '/deletenotification': rateLimit({
+        windowMs: 1000 * 60, //1 minute
+        max: 60,
+        standardHeaders: false,
+        legacyHeaders: false,
+        message: {status: "FAILED", message: "You have deleted too many notifications in the last minute. Please try again in 60 seconds."},
+        skipFailedRequests: true,
+        keyGenerator: (req, res) => req.tokenData //Use req.tokenData (account _id in MongoDB) to identify clients and rate limit
+    }),
+    '/getnotifications': rateLimit({
+        windowMs: 1000 * 60, //1 minute
+        max: 5,
+        standardHeaders: false,
+        legacyHeaders: false,
+        message: {status: "FAILED", message: "You have retrieved your notifications too many times in the last minute. Please try again in 60 seconds."},
+        skipFailedRequests: true,
+        keyGenerator: (req, res) => req.tokenData //Use req.tokenData (account _id in MongoDB) to identify clients and rate limit
+    }),
     '/followuser': rateLimit({
         windowMs: 1000 * 60, //1 minute
         max: 6,
@@ -3119,6 +3146,93 @@ router.post('/removevoteonpost', rateLimiters['/removevoteonpost'], (req, res) =
     })
 });
 
+router.post('/clearnotifications', rateLimiters['/clearnotifications'], (req, res) => {
+    let HTTPHeadersSent = false;
+    const worker = new Worker(workerPath, {
+        workerData: {
+            functionName: 'clearnotifications',
+            functionArgs: [req.tokenData]
+        }
+    })
+
+    worker.on('message', (result) => {
+        if (!HTTPHeadersSent) {
+            HTTPHeadersSent = true;
+            res.status(result.statusCode).json(result.data)
+        } else {
+            console.error('POST temp/clearnotifications controller function returned data to be sent to the client but HTTP headers have already been sent! Data attempted to send:', result)
+        }
+    })
+
+    worker.on('error', (error) => {
+        if (!HTTPHeadersSent) {
+            HTTPHeadersSent = true;
+            console.error('An error occurred from TempWorker for POST /clearnotifications:', error)
+            HTTPHandler.serverError(res, String(error))
+        } else {
+            console.error('POST temp/clearnotifications controller function encountered an error and tried to send it to the client but HTTP headers have already been sent! Error attempted to send:', error)
+        }
+    })
+});
+
+router.post('/deletenotification', rateLimiters['/deletenotification'], (req, res) => {
+    let HTTPHeadersSent = false;
+    const worker = new Worker(workerPath, {
+        workerData: {
+            functionName: 'deletenotification',
+            functionArgs: [req.tokenData, req.body.notificationId]
+        }
+    })
+
+    worker.on('message', (result) => {
+        if (!HTTPHeadersSent) {
+            HTTPHeadersSent = true;
+            res.status(result.statusCode).json(result.data)
+        } else {
+            console.error('POST temp/deletenotification controller function returned data to be sent to the client but HTTP headers have already been sent! Data attempted to send:', result)
+        }
+    })
+
+    worker.on('error', (error) => {
+        if (!HTTPHeadersSent) {
+            HTTPHeadersSent = true;
+            console.error('An error occurred from TempWorker for POST /deletenotification:', error)
+            HTTPHandler.serverError(res, String(error))
+        } else {
+            console.error('POST temp/deletenotification controller function encountered an error and tried to send it to the client but HTTP headers have already been sent! Error attempted to send:', error)
+        }
+    })
+});
+
+router.post('/getnotifications', rateLimiters['/getnotifications'], (req, res) => {
+    let HTTPHeadersSent = false;
+    const worker = new Worker(workerPath, {
+        workerData: {
+            functionName: 'getnotifications',
+            functionArgs: [req.tokenData, req.body.lastNotificationId]
+        }
+    })
+
+    worker.on('message', (result) => {
+        if (!HTTPHeadersSent) {
+            HTTPHeadersSent = true;
+            res.status(result.statusCode).json(result.data)
+        } else {
+            console.error('GET temp/getnotifications controller function returned data to be sent to the client but HTTP headers have already been sent! Data attempted to send:', result)
+        }
+    })
+
+    worker.on('error', (error) => {
+        if (!HTTPHeadersSent) {
+            HTTPHeadersSent = true;
+            console.error('An error occurred from TempWorker for GET /getnotifications:', error)
+            HTTPHandler.serverError(res, String(error))
+        } else {
+            console.error('GET temp/getnotifications controller function encountered an error and tried to send it to the client but HTTP headers have already been sent! Error attempted to send:', error)
+        }
+    })
+});
+
 router.post('/followuser', rateLimiters['/followuser'], (req, res) => {
     let HTTPHeadersSent = false;
     const worker = new Worker(workerPath, {

tests/TEST_CONSTANTS.js

@@ -11,7 +11,8 @@ const TEST_CONSTANTS = {
                 resolve(false);
             })
         })
-    }
+    },
+    RANDOM_OBJECTIDS: ["6560b01ec5ea35f173c645d4", "6560b0310a9b4c4ee26ce297", "6560b036dbc1f1384347ff61", "6560b047f1045829ebdb6e3b", "6560b0633f3b8652f95e4224"]
 }
 
 module.exports = TEST_CONSTANTS;