Added ChatMessage schema & fixed api logic so it actually stores each chatMessage in the db (#1822)

* added ChatMessage schema & modified writeMessage function to write to mongodb

* modified /getLatestmessage to get the latest message, need to test it out in postman now

* updated writeMessage to be async for proper mongoDB chatMessage creation

* getLatestMessage now works for specific chatRoom ids, gets the userid via querying the User database by username and then extracting the userId

* uncommented out some token and apikey logic

* fixed lint errors yay

* reverted the package-lock.json file to the one from dev branch

* removed all the random styling changes, kept only the logic changes

* changed from expiresAt to expireAt and added TTL index for automatic expiration

* made writing to mongoDb as a seperate function

* removed the extracting username logic from writeMessage.

* fixed lint errors

* removed writeToMongo function, just added it inside the /send route

* Fixed lint errors

Author: Sujan30

api/main_endpoints/models/ChatMessage.js

@@ -0,0 +1,35 @@
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+const ChatMessageSchema = new Schema(
+  {
+    createdAt: {
+      type: Date,
+      default: Date.now(),
+    },
+    expiresAt: {
+      type: Date,
+      default: ()=> Date.now() + 24 * 3600 * 1000, // expires in 24 hours
+    },
+    chatroomId: {
+      type: String,
+      required: true,
+    },
+    userId: {
+      type: Schema.Types.ObjectId,
+      ref: 'User',
+      required: true,
+    },
+    text: {
+      type: String,
+      required: true,
+    }
+  }
+);
+
+ChatMessageSchema.index({chatroomId: 1, createdAt: -1}); // sort by whatever is created most currently
+ChatMessageSchema.index({expiresAt: 1}, {expireAfterSeconds: 0}); // TTL index for automatic expiration
+
+module.exports = mongoose.model('ChatMessage', ChatMessageSchema);
+
+

api/main_endpoints/routes/Messages.js

@@ -13,6 +13,7 @@ const logger = require('../../util/logger');
 const client = require('prom-client');
 const { decodeToken, decodeTokenFromBodyOrQuery } = require('../util/token-functions.js');
 const { MetricsHandler, register } = require('../../util/metrics.js');
+const ChatMessage = require('../models/ChatMessage.js');
 
 
 router.use(bodyParser.json());
@@ -23,7 +24,8 @@ const clients = {};
 const numberOfConnections = {};
 const lastMessageSent = {};
 
-const writeMessage = ((roomId, message, username) => {
+
+const writeMessage = (roomId, message, username) => {
 
   const messageObj = {
     timestamp: Date.now(),
@@ -37,12 +39,13 @@ const writeMessage = ((roomId, message, username) => {
 
   lastMessageSent[roomId] = JSON.stringify(messageObj);
 
+
   // increase the total messages sent counter
   MetricsHandler.totalMessagesSent.inc();
 
   // increase the total amount of messages sent per chatroom counter
   MetricsHandler.totalChatMessagesPerChatRoom.labels(roomId).inc();
-});
+};
 
 router.post('/send', async (req, res) => {
 
@@ -65,6 +68,7 @@ router.post('/send', async (req, res) => {
   }
 
   let nameToUse = null;
+  let userId = null;
 
   if (apiKey) {
     try {
@@ -73,20 +77,30 @@ router.post('/send', async (req, res) => {
         return res.sendStatus(UNAUTHORIZED);
       }
       nameToUse = result.firstName;
+      userId = result._id;
+      await writeToMongo(id, message, userId);
     } catch (error) {
       logger.error('Error in /send User.findOne: ', error);
       return res.sendStatus(SERVER_ERROR);
     }
+  } else {
+    const userObj = decodeToken(req);
+    if (!userObj) {
+      return res.sendStatus(UNAUTHORIZED);
+    }
+    nameToUse = userObj.firstName;
+    userId = userObj._id;
   }
-
-  // Assume user passed a non null/undefined token
-  const userObj = decodeToken(req);
-  if (!userObj) {
-    return res.sendStatus(UNAUTHORIZED);
-  }
-  nameToUse = userObj.firstName;
   try {
     writeMessage(id, `${message}`, `${nameToUse}:`);
+
+    ChatMessage.create({
+      chatroomId: id,
+      text: message,
+      userId: userId
+    }).catch(err => {
+      logger.error('Error in /send ChatMessage.create: ', err);
+    });
     return res.json({ status: 'Message sent' });
   } catch (error) {
     logger.error('Error in /send writeMessage: ', error);
@@ -103,33 +117,23 @@ router.get('/getLatestMessage', async (req, res) => {
   ];
 
   const missingValue = required.find(({value}) => !value);
-
   if (missingValue){
     res.status(BAD_REQUEST).send(`You must specify a ${missingValue.title}`);
     return;
   }
 
   try {
-    User.findOne({ apiKey }, (error, result) => {
-      if (error) {
-        logger.error('/listen received an invalid API key: ', error);
-        res.sendStatus(SERVER_ERROR);
-        return;
-      }
-
-      if (!result) { // return unauthorized if no api key found
-        return res.sendStatus(UNAUTHORIZED);
-      }
+    const user = await User.findOne({apiKey});
+    if(!user){
+      return res.sendStatus(UNAUTHORIZED);
+    }
 
-      if (!lastMessageSent[id]) {
-        return res.status(OK).send('Room closed');
-      }
+    const messages = await ChatMessage.find({chatroomId: id}).sort({createdAt: -1}).limit(20).populate('userId');
 
-      return res.status(OK).send(lastMessageSent[id]);
+    return res.status(OK).json(messages);
 
-    });
   } catch (error) {
-    logger.error('Error in /get: ', error);
+    logger.error('Error in /getLatestMessage: ', error);
     res.sendStatus(SERVER_ERROR);
   }
 });
@@ -144,7 +148,6 @@ router.get('/listen', async (req, res) => {
   ];
 
   const missingValue = required.find(({value}) => !value);
-
   if (missingValue){
     res.status(BAD_REQUEST).send(`You must specify a ${missingValue.title}`);
     return;
@@ -174,7 +177,6 @@ router.get('/listen', async (req, res) => {
       }
 
       const { _id } = result;
-
       numberOfConnections[_id] = numberOfConnections[_id] ? numberOfConnections[_id] + 1 : 1;
 
       const headers = {