Merge pull request #1165 from Real-Dev-Squad/feat/event-join-peer-api

Author: iamitprakash

controllers/events.js

@@ -1,9 +1,11 @@
-/* eslint-disable camelcase */
 const { GET_ALL_EVENTS_LIMIT_MIN, UNWANTED_PROPERTIES_FROM_100MS } = require("../constants/events");
+const { INTERNAL_SERVER_ERROR } = require("../constants/errorMessages");
+
 const { EventTokenService, EventAPIService } = require("../services");
-const { removeUnwantedProperties } = require("../utils/events");
 const eventQuery = require("../models/events");
+
 const logger = require("../utils/logger");
+const { removeUnwantedProperties } = require("../utils/events");
 
 const tokenService = new EventTokenService();
 const apiService = new EventAPIService(tokenService);
@@ -100,7 +102,7 @@ const joinEvent = async (req, res) => {
     });
   } catch (error) {
     logger.error({ error });
-    return res.status(500).send("Internal Server Error");
+    return res.boom.badImplementation(INTERNAL_SERVER_ERROR);
   }
 };
 
@@ -193,11 +195,77 @@ const endActiveEvent = async (req, res) => {
   }
 };
 
+/**
+ * Adds a peer to an event.
+ *
+ * @async
+ * @function
+ * @param {Object} req - The Express request object.
+ * @param {Object} res - The Express response object.
+ * @returns {Promise<Object>} The JSON response with the added peer data and a success message.
+ * @throws {Object} The JSON response with an error message if an error occurred while adding the peer.
+ */
+const addPeerToEvent = async (req, res) => {
+  try {
+    const data = await eventQuery.addPeerToEvent({
+      peerId: req.body.peerId,
+      name: req.body.name,
+      role: req.body.role,
+      joinedAt: req.body.joinedAt,
+      eventId: req.params.id,
+    });
+    return res.status(200).json({
+      data,
+      message: `Selected Participant is added to the event.`,
+    });
+  } catch (error) {
+    logger.error({ error });
+    return res.status(500).json({
+      error: error.code,
+      message: "You can't add selected Participant. Please ask Admin or Host for help.",
+    });
+  }
+};
+
+/**
+ * Kicks out a peer from an event.
+ *
+ * @async
+ * @function
+ * @param {Object} req - The Express request object.
+ * @param {Object} res - The Express response object.
+ * @returns {Promise<Object>} The JSON response with a success message if the peer is successfully kicked out.
+ * @throws {Object} The JSON response with an error message if an error occurred while kicking out the peer.
+ */
+const kickoutPeer = async (req, res) => {
+  const { id } = req.params;
+  const payload = {
+    peer_id: req.body.peerId,
+    reason: req.body.reason,
+  };
+
+  try {
+    await apiService.post(`/active-rooms/${id}/remove-peers`, payload);
+    await eventQuery.kickoutPeer({ eventId: id, peerId: payload.peer_id, reason: req.body.reason });
+    return res.status(200).json({
+      message: `Selected Participant is removed from event.`,
+    });
+  } catch (error) {
+    logger.error({ error });
+    return res.status(500).json({
+      error: error.code,
+      message: "You can't remove selected Participant from Remove, Please ask Admin or Host for help.",
+    });
+  }
+};
+
 module.exports = {
   createEvent,
   getAllEvents,
   joinEvent,
   getEventById,
   updateEvent,
   endActiveEvent,
+  addPeerToEvent,
+  kickoutPeer,
 };

middlewares/validators/events.js

@@ -100,11 +100,57 @@ const endActiveEvent = async (req, res, next) => {
   }
 };
 
+const addPeerToEvent = async (req, res, next) => {
+  const { id } = req.params;
+  const { peerId, name, role, joinedAt } = req.body;
+
+  const schema = joi.object({
+    peerId: joi.string().required(),
+    name: joi.string().required(),
+    id: joi.string().required(),
+    role: joi.string().required(),
+    joinedAt: joi.date().required(),
+  });
+
+  const validationOptions = { abortEarly: false };
+
+  try {
+    await schema.validateAsync({ peerId, name, id, role, joinedAt }, validationOptions);
+    next();
+  } catch (error) {
+    logger.error(`Error while adding a peer to the event: ${error}`);
+    res.boom.badRequest(error.details[0].message);
+  }
+};
+
+const kickoutPeer = async (req, res, next) => {
+  const { id } = req.params;
+  const { peerId, reason } = req.body;
+
+  const schema = joi.object({
+    id: joi.string().required(),
+    peerId: joi.string().required(),
+    reason: joi.string().required(),
+  });
+
+  const validationOptions = { abortEarly: false };
+
+  try {
+    await schema.validateAsync({ id, peerId, reason }, validationOptions);
+    next();
+  } catch (error) {
+    logger.error(`We encountered some error while removing selected Participant from event: ${error}`);
+    res.boom.badRequest(error.details[0].message);
+  }
+};
+
 module.exports = {
   createEvent,
   getAllEvents,
   joinEvent,
   getEventById,
   updateEvent,
   endActiveEvent,
+  addPeerToEvent,
+  kickoutPeer,
 };

models/events.js

@@ -1,7 +1,9 @@
+const Firestore = require("@google-cloud/firestore");
 const firestore = require("../utils/firestore");
 const logger = require("../utils/logger");
 
 const eventModel = firestore.collection("events");
+const peerModel = firestore.collection("peers");
 
 /**
  * Creates a new event document in Firestore and returns the data for the created document.
@@ -66,8 +68,112 @@ const endActiveEvent = async ({ id, reason, lock }) => {
   }
 };
 
+/**
+ * Adds a peer to an event in the Firestore database.
+ * @async
+ * @function
+ * @param {Object} peerData - The data of the peer to be added.
+ * @param {string} peerData.name - The name of the peer.
+ * @param {string} peerData.eventId - The unique identifier of the event the peer is being added to.
+ * @param {string} peerData.role - The role of the peer in the event.
+ * @param {Date} peerData.joinedAt - The timestamp indicating when the peer joined the event.
+ * @returns {Promise<Object>} The data of the added peer.
+ * @throws {Error} If an error occurs while adding the peer to the event.
+ */
+
+const addPeerToEvent = async (peerData) => {
+  try {
+    const batch = firestore.batch();
+
+    const peerRef = peerModel.doc(peerData.peerId);
+    const peerDocSnapshot = await peerRef.get();
+
+    if (!peerDocSnapshot.exists) {
+      // If the peer document doesn't exist, create a new one
+      const peerDocData = {
+        peerId: peerData.peerId,
+        name: peerData.name,
+        joinedEvents: [
+          {
+            event_id: peerData.eventId,
+            role: peerData.role,
+            joined_at: peerData.joinedAt,
+          },
+        ],
+      };
+      batch.set(peerRef, peerDocData);
+    } else {
+      // If the peer document exists, update the joinedEvents array
+      batch.update(peerRef, {
+        joinedEvents: Firestore.FieldValue.arrayUnion({
+          event_id: peerData.eventId,
+          role: peerData.role,
+          joined_at: peerData.joinedAt,
+        }),
+      });
+    }
+
+    const eventRef = eventModel.doc(peerData.eventId);
+    batch.update(eventRef, {
+      peers: Firestore.FieldValue.arrayUnion(peerRef.id),
+    });
+
+    await batch.commit();
+
+    const updatedPeerSnapshot = await peerRef.get();
+    return updatedPeerSnapshot.data();
+  } catch (error) {
+    logger.error("Error in adding peer to the event", error);
+    throw error;
+  }
+};
+
+/**
+ * Removes a peer from an event and marks them as kicked out in the Firestore database.
+ * @async
+ * @function
+ * @param {Object} params - The parameters for kicking out the peer.
+ * @param {string} params.eventId - The unique identifier of the event from which the peer is being kicked out.
+ * @param {string} params.peerId - The unique identifier of the peer being kicked out.
+ * @param {string} params.reason - The reason for kicking out the peer from the event.
+ * @returns {Promise<Object>} The updated data of the kicked-out peer.
+ * @throws {Error} If the peer is not found or is not part of the specified event.
+ */
+const kickoutPeer = async ({ eventId, peerId, reason }) => {
+  try {
+    const peerRef = peerModel.doc(peerId);
+    const peerSnapshot = await peerRef.get();
+
+    if (!peerSnapshot.exists) {
+      throw new Error("Participant not found");
+    }
+
+    const peerData = peerSnapshot.data();
+    const joinedEvents = peerData.joinedEvents;
+
+    const eventIndex = joinedEvents.findIndex((event) => event.event_id === eventId);
+    if (eventIndex === -1) {
+      throw new Error("Participant is not part of the specified event");
+    }
+
+    const updatedJoinedEvents = joinedEvents.map((event, index) =>
+      index === eventIndex ? { ...event, left_at: new Date(), reason: reason, isKickedout: true } : event
+    );
+
+    await peerRef.update({ joinedEvents: updatedJoinedEvents });
+
+    const updatedPeerSnapshot = await peerRef.get();
+    return updatedPeerSnapshot.data();
+  } catch (error) {
+    logger.error("Error in removing peer from the event.", error);
+    throw error;
+  }
+};
+
 module.exports = {
   createEvent,
   updateEvent,
   endActiveEvent,
+  addPeerToEvent,
+  kickoutPeer,
 };

routes/events.js

@@ -10,5 +10,7 @@ router.post("/join", eventsValidator.joinEvent, events.joinEvent);
 router.get("/:id", eventsValidator.getEventById, events.getEventById);
 router.patch("/", authenticate, eventsValidator.updateEvent, events.updateEvent);
 router.patch("/end", authenticate, eventsValidator.endActiveEvent, events.endActiveEvent);
+router.post("/:id/peers", authenticate, eventsValidator.addPeerToEvent, events.addPeerToEvent);
+router.patch("/:id/peers/kickout", authenticate, eventsValidator.kickoutPeer, events.kickoutPeer);
 
 module.exports = router;