Merge pull request #1757 from Real-Dev-Squad/develop

Dev to main Sync

Author: iamitprakash

config/development.js

@@ -10,6 +10,7 @@ module.exports = {
   port: port,
   enableFileLogs: false,
   enableConsoleLogs: true,
+  discordNewComersChannelId: "709080951824842783",
 
   services: {
     rdsApi: {

config/test.js

@@ -11,6 +11,7 @@ module.exports = {
   enableConsoleLogs: true,
   discordUnverifiedRoleId: "1234567890",
   discordDeveloperRoleId: "9876543210",
+  discordNewComersChannelId: "709080951824842783",
   discordMavenRoleId: "1212121212",
   githubOauth: {
     clientId: "clientId",

controllers/discordactions.js

@@ -403,6 +403,75 @@ const setRoleToUsersWith31DaysPlusOnboarding = async (req, res) => {
   }
 };
 
+const generateInviteForUser = async (req, res) => {
+  try {
+    const { userId } = req.query;
+    const userIdForInvite = userId || req.userData.id;
+
+    const modelResponse = await discordRolesModel.getUserDiscordInvite(userIdForInvite);
+
+    if (!modelResponse.notFound) {
+      return res.status(409).json({
+        message: "User invite is already present!",
+      });
+    }
+
+    const channelId = config.get("discordNewComersChannelId");
+    const authToken = jwt.sign({}, config.get("rdsServerlessBot.rdsServerLessPrivateKey"), {
+      algorithm: "RS256",
+      expiresIn: config.get("rdsServerlessBot.ttl"),
+    });
+
+    const inviteOptions = {
+      channelId: channelId,
+    };
+    const response = await fetch(`${DISCORD_BASE_URL}/invite`, {
+      method: "POST",
+      body: JSON.stringify(inviteOptions),
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${authToken}` },
+    });
+    const discordInviteResponse = await response.json();
+
+    const inviteCode = discordInviteResponse.data.code;
+    const inviteLink = `discord.gg/${inviteCode}`;
+
+    await discordRolesModel.addInviteToInviteModel({ userId: userIdForInvite, inviteLink });
+
+    return res.status(201).json({
+      message: "invite generated successfully",
+      inviteLink,
+    });
+  } catch (err) {
+    logger.error(`Error in generating invite for user: ${err}`);
+    return res.boom.badImplementation(INTERNAL_SERVER_ERROR);
+  }
+};
+
+const getUserDiscordInvite = async (req, res) => {
+  try {
+    const { userId } = req.query;
+    const isSuperUser = req.userData.roles.super_user;
+
+    if (userId && !isSuperUser) return res.boom.forbidden("User should be super user to get link for other users");
+
+    const userIdForInvite = userId || req.userData.id;
+
+    const invite = await discordRolesModel.getUserDiscordInvite(userIdForInvite);
+
+    if (invite.notFound) {
+      return res.boom.notFound("User invite doesn't exist");
+    }
+
+    return res.json({
+      message: "Invite returned successfully",
+      inviteLink: invite?.inviteLink,
+    });
+  } catch (err) {
+    logger.error(`Error in fetching user invite: ${err}`);
+    return res.boom.badImplementation(INTERNAL_SERVER_ERROR);
+  }
+};
+
 module.exports = {
   getGroupsRoleId,
   createGroupRole,
@@ -416,4 +485,6 @@ module.exports = {
   updateUsersNicknameStatus,
   syncDiscordGroupRolesInFirestore,
   setRoleToUsersWith31DaysPlusOnboarding,
+  getUserDiscordInvite,
+  generateInviteForUser,
 };

controllers/fcmToken.js

@@ -0,0 +1,29 @@
+const { saveFcmToken } = require("../models/fcmToken");
+const { Conflict } = require("http-errors");
+
+/**
+ * Route used to get the health status of teh server
+ *
+ * @param req {Object} - Express request object
+ * @param res {Object} - Express response object
+ */
+const fcmTokenController = async (req, res) => {
+  try {
+    const { fcmToken } = req.body;
+
+    const fcmTokenId = await saveFcmToken({ userId: req.userData.id, fcmToken });
+    if (fcmTokenId) res.status(200).json({ status: 200, message: "Device registered successfully" });
+  } catch (error) {
+    if (error instanceof Conflict) {
+      return res.status(409).json({
+        message: error.message,
+      });
+    }
+    res.status(500).send("Something went wrong, please contact admin");
+  }
+  return res.status(500).send("Internal server error");
+};
+
+module.exports = {
+  fcmTokenController,
+};

controllers/notify.js

@@ -0,0 +1,83 @@
+const admin = require("firebase-admin");
+const { getFcmTokenFromUserId } = require("../services/getFcmTokenFromUserId");
+const { getUserIdsFromRoleId } = require("../services/getUserIdsFromRoleId");
+
+/**
+ * Route used to get the health status of teh server
+ *
+ * @param req {Object} - Express request object
+ * @param res {Object} - Express response object
+ */
+const notifyController = async (req, res) => {
+  const { title, body, userId, groupRoleId } = req.body;
+  let fcmTokens = [];
+  if (userId) {
+    const fcmTokensFromUserId = await getFcmTokenFromUserId(userId);
+    fcmTokens = [...fcmTokens, ...fcmTokensFromUserId];
+  }
+
+  let userIdsFromRoleId = [];
+  let fcmTokensFromUserId;
+  if (groupRoleId) {
+    try {
+      userIdsFromRoleId = await getUserIdsFromRoleId(groupRoleId);
+    } catch (error) {
+      logger.error("error ", error);
+      throw error;
+    }
+
+    const fcmTokensPromiseArray = userIdsFromRoleId.map(async (userId) => {
+      try {
+        fcmTokensFromUserId = await getFcmTokenFromUserId(userId);
+      } catch (error) {
+        logger.error("error ", error);
+        throw error;
+      }
+      fcmTokens = [...fcmTokens, ...fcmTokensFromUserId];
+    });
+    try {
+      await Promise.all(fcmTokensPromiseArray);
+    } catch (error) {
+      logger.error("error", error);
+      throw error;
+    }
+  }
+
+  const setOfFcmTokens = new Set(fcmTokens);
+
+  const message = {
+    notification: {
+      title: title || "Notification Title",
+      body: body || "Notification Body",
+    },
+    data: {
+      key1: "value1",
+      key2: "value2",
+    },
+    tokens: Array.from(setOfFcmTokens),
+  };
+  function calculateMessageSize(message) {
+    const byteArray = new TextEncoder().encode(message);
+
+    const byteLength = byteArray.length;
+
+    const kilobytes = byteLength / 1024;
+
+    return kilobytes;
+  }
+  if (calculateMessageSize(message) >= 2) {
+    res.error(401).send("Message length exceeds");
+  }
+  admin
+    .messaging()
+    .sendMulticast(message)
+    .then(() => res.status(200).json({ status: 200, message: "User notified successfully" }))
+    .catch((error) => {
+      logger.error("Error sending message:", error);
+      res.status(500).json({ status: 500, message: "Internal server error" });
+    });
+};
+
+module.exports = {
+  notifyController,
+};

middlewares/checkCanGenerateDiscordLink.ts

@@ -0,0 +1,28 @@
+import { NextFunction } from "express";
+import { CustomRequest, CustomResponse } from "../types/global";
+
+const checkCanGenerateDiscordLink = async (req: CustomRequest, res: CustomResponse, next: NextFunction) => {
+  const { discordId, roles, id: userId, profileStatus } = req.userData;
+  const isSuperUser = roles.super_user;
+  const userIdInQuery = req.query.userId;
+
+  if (userIdInQuery && userIdInQuery !== userId && !isSuperUser) {
+    return res.boom.forbidden("User should be super user to generate link for other users");
+  }
+
+  if (discordId) {
+    return res.boom.forbidden("Only users who have never joined discord can generate invite link");
+  }
+
+  if (roles.archived) {
+    return res.boom.forbidden("Archived users cannot generate invite");
+  }
+
+  if (!roles.maven && !roles.designer && !roles.product_manager && profileStatus !== "VERIFIED") {
+    return res.boom.forbidden("Only selected roles can generate discord link directly");
+  }
+
+  return next();
+};
+
+module.exports = checkCanGenerateDiscordLink;

middlewares/validators/fcmToken.js

@@ -0,0 +1,14 @@
+const joi = require("joi");
+
+export const fcmTokenValidator = async (req, res, next) => {
+  const schema = joi.object().strict().keys({
+    fcmToken: joi.string().required(),
+  });
+  try {
+    await schema.validateAsync(req.body);
+    next();
+  } catch (error) {
+    logger.error(`Bad request body : ${error}`);
+    res.boom.badRequest(error.details[0].message);
+  }
+};

middlewares/validators/notify.js

@@ -0,0 +1,24 @@
+const joi = require("joi");
+
+export const notifyValidator = async (req, res, next) => {
+  const MAX_TITLE_LENGTH = 512;
+  const MAX_BODY_LENGTH = 1536;
+
+  const schema = joi
+    .object()
+    .strict()
+    .keys({
+      title: joi.string().required().max(MAX_TITLE_LENGTH).required(),
+      body: joi.string().required().max(MAX_BODY_LENGTH).required(),
+      userId: joi.string(),
+      groupRoleId: joi.string(),
+    })
+    .xor("userId", "groupRoleId");
+  try {
+    await schema.validateAsync(req.body);
+    next();
+  } catch (error) {
+    logger.error(`Bad request body : ${error}`);
+    res.boom.badRequest(error.details[0].message);
+  }
+};

models/discordactions.js

@@ -2,6 +2,7 @@ const { generateDiscordProfileImageUrl } = require("../utils/discord-actions");
 const firestore = require("../utils/firestore");
 const discordRoleModel = firestore.collection("discord-roles");
 const memberRoleModel = firestore.collection("member-group-roles");
+const discordInvitesModel = firestore.collection("discord-invites");
 const admin = require("firebase-admin");
 const { findSubscribedGroupIds } = require("../utils/helper");
 const { retrieveUsers } = require("../services/dataAccessLayer");
@@ -830,6 +831,31 @@ const updateUsersWith31DaysPlusOnboarding = async () => {
   }
 };
 
+const addInviteToInviteModel = async (inviteObject) => {
+  try {
+    const invite = await discordInvitesModel.add(inviteObject);
+    return invite.id;
+  } catch (err) {
+    logger.error("Error in adding invite", err);
+    throw err;
+  }
+};
+
+const getUserDiscordInvite = async (userId) => {
+  try {
+    const invite = await discordInvitesModel.where("userId", "==", userId).get();
+    const [inviteDoc] = invite.docs;
+    if (inviteDoc) {
+      return { id: inviteDoc.id, ...inviteDoc.data(), notFound: false };
+    } else {
+      return { notFound: true };
+    }
+  } catch (err) {
+    logger.log("error in getting user invite", err);
+    throw err;
+  }
+};
+
 module.exports = {
   createNewRole,
   removeMemberGroup,
@@ -847,4 +873,6 @@ module.exports = {
   updateUsersNicknameStatus,
   updateIdle7dUsersOnDiscord,
   updateUsersWith31DaysPlusOnboarding,
+  getUserDiscordInvite,
+  addInviteToInviteModel,
 };

models/fcmToken.js

@@ -0,0 +1,40 @@
+const firestore = require("../utils/firestore");
+const { Conflict } = require("http-errors");
+
+const fcmTokenModel = firestore.collection("fcmToken");
+
+const saveFcmToken = async (fcmTokenData) => {
+  try {
+    const fcmTokenSnapshot = await fcmTokenModel.where("userId", "==", fcmTokenData.userId).limit(1).get();
+
+    if (fcmTokenSnapshot.empty) {
+      const fcmToken = await fcmTokenModel.add({
+        userId: fcmTokenData.userId,
+        fcmTokens: [fcmTokenData.fcmToken],
+      });
+      return fcmToken.id;
+    } else {
+      let fcmTokenObj = {};
+      fcmTokenSnapshot.forEach((fcmToken) => {
+        fcmTokenObj = {
+          id: fcmToken.id,
+          ...fcmToken.data(),
+        };
+      });
+      if (!fcmTokenObj.fcmTokens.includes(fcmTokenData.fcmToken)) {
+        fcmTokenObj.fcmTokens.push(fcmTokenData.fcmToken);
+        await fcmTokenModel.doc(fcmTokenObj.id).update({
+          fcmTokens: fcmTokenObj.fcmTokens,
+        });
+        return fcmTokenObj.id;
+      } else {
+        throw new Conflict("Device Already Registered");
+      }
+    }
+  } catch (err) {
+    logger.error("Error in adding fcm token", err);
+    throw err;
+  }
+};
+
+module.exports = { saveFcmToken };