feat: enhance Discord invite generation and role handling

controllers/discordactions.js

@@ -23,7 +23,8 @@ const DISCORD_BASE_URL = config.get("services.discordBot.baseUrl");
 
 const createGroupRole = async (req, res) => {
   try {
-    const rolename = `group-${req.body.rolename}`;
+    const { role = false } = req.query;
+    const rolename = role ? req.body.rolename : `group-${req.body.rolename}`;
 
     const { roleExists } = await discordRolesModel.isGroupRoleExists({ rolename });
 
@@ -505,6 +506,7 @@ const generateInviteForUser = async (req, res) => {
 
     const inviteOptions = {
       channelId: channelId,
+      role: req.approvedApplicationRole,
     };
     const response = await fetch(`${DISCORD_BASE_URL}/invite`, {
       method: "POST",

controllers/external-accounts.js

@@ -5,7 +5,6 @@ const { addOrUpdate, getUsersByRole, updateUsersInBatch } = require("../models/u
 const { retrieveDiscordUsers, fetchUsersForKeyValues } = require("../services/dataAccessLayer");
 const { EXTERNAL_ACCOUNTS_POST_ACTIONS } = require("../constants/external-accounts");
 const removeDiscordRoleUtils = require("../utils/removeDiscordRoleFromUser");
-const addDiscordRoleUtils = require("../utils/addDiscordRoleToUser");
 const config = require("config");
 const logger = require("../utils/logger");
 const { markUnDoneTasksOfArchivedUsersBacklog } = require("../models/tasks");
@@ -80,30 +79,7 @@ const linkExternalAccount = async (req, res) => {
     );
 
     if (!unverifiedRoleRemovalResponse.success) {
-      // Tolerable errors that should not block role assignment
-      const tolerableErrors = ["Role doesn't exist", "Role deletion from database failed"];
-      const isTolerableError = tolerableErrors.some((err) => unverifiedRoleRemovalResponse.message.includes(err));
-
-      if (!isTolerableError) {
-        const message = `User details updated but ${unverifiedRoleRemovalResponse.message}. Please contact admin`;
-        return res.boom.internal(message, { message });
-      }
-      logger.info(
-        `Tolerable error during unverified role removal for Discord ID: ${attributes.discordId}: ${unverifiedRoleRemovalResponse.message}`
-      );
-    }
-
-    const developerRoleId = config.get("discordDeveloperRoleId");
-    const newRoleId = config.get("discordNewRoleId");
-
-    try {
-      await addDiscordRoleUtils.addDiscordRoleToUser(attributes.discordId, developerRoleId, "Developer");
-      await addDiscordRoleUtils.addDiscordRoleToUser(attributes.discordId, newRoleId, "New");
-      logger.info(`Roles (Developer, New) assigned successfully for Discord ID: ${attributes.discordId}`);
-    } catch (roleError) {
-      logger.error(`Error assigning roles after verification: ${roleError}`);
-      const message = `Your discord profile has been linked but role assignment failed. Please contact admin`;
-      return res.boom.internal(message, { message });
+      return res.boom.internal(null, { message: "Unverified role removal failed. Please contact admin" });
     }
 
     return res.status(200).json({ message: "Your discord profile has been linked successfully" });

middlewares/checkCanGenerateDiscordLink.ts

@@ -23,11 +23,16 @@ const checkCanGenerateDiscordLink = async (req: CustomRequest, res: CustomRespon
     }
 
     const approvedApplication = applications.find((application: { status: string; }) => application.status === 'accepted');
-    
+
     if (!approvedApplication) {
       return res.boom.forbidden("Only users with an accepted application can generate a Discord invite link.");
     }
 
+    if (approvedApplication.isNew !== true || !approvedApplication.role) {
+      return res.boom.forbidden("You are not eligible to generate a Discord invite link.");
+    }
+
+    req.approvedApplicationRole = approvedApplication.role;
     return next();
   } catch (error) {
     return res.boom.badImplementation("An error occurred while checking user applications.");

middlewares/validators/discordactions.js

@@ -1,14 +1,20 @@
 const Joi = require("joi");
 const { validateMillisecondsTimestamp } = require("./utils");
+const logger = require("../../utils/logger");
 
 const validateGroupRoleBody = async (req, res, next) => {
-  const schema = Joi.object({
+  const bodySchema = Joi.object({
     rolename: Joi.string().trim().required(),
     description: Joi.string().trim(),
   });
 
+  const querySchema = Joi.object({
+    role: Joi.boolean().default(false).optional(),
+  });
+
   try {
-    await schema.validateAsync(req.body);
+    await bodySchema.validateAsync(req.body);
+    req.query = await querySchema.validateAsync(req.query);
     next();
   } catch (error) {
     logger.error(`Error validating createGroupRole payload : ${error}`);

routes/discordactions.js

@@ -47,7 +47,7 @@
  * Short-circuit this POST method for this endpoint
  * Refer https://github.com/Real-Dev-Squad/todo-action-items/issues/269 for more details.
  */
-router.post("/invite", disableRoute, authenticate, checkCanGenerateDiscordLink, generateInviteForUser);
+router.post("/invite", authenticate, checkCanGenerateDiscordLink, generateInviteForUser);
 
 router.delete("/roles", authenticate, checkIsVerifiedDiscord, deleteRole);
 router.get("/roles", authenticate, checkIsVerifiedDiscord, getGroupsRoleId);

test/integration/discordactions.test.js

@@ -1377,4 +1377,192 @@ describe("Discord actions", function () {
         });
     });
   });
+
+  describe("POST /discord-actions/groups (createGroupRole)", function () {
+    let testUserId;
+    let testUserAuthToken;
+
+    beforeEach(async function () {
+      testUserId = await addUser(userData[0]);
+      testUserAuthToken = authService.generateAuthToken({ userId: testUserId });
+
+      fetchStub.returns(
+        Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve({ id: "discord-role-id-123" }),
+        })
+      );
+
+      sinon.stub(discordRolesModel, "isGroupRoleExists").resolves({
+        roleExists: false,
+      });
+    });
+
+    afterEach(async function () {
+      await cleanDb();
+    });
+
+    it("should create a group role with 'group-' prefix when role query param is not provided", function (done) {
+      const roleData = {
+        rolename: "developers",
+        description: "Test group role",
+      };
+
+      chai
+        .request(app)
+        .post("/discord-actions/groups")
+        .set("cookie", `${cookieName}=${testUserAuthToken}`)
+        .send(roleData)
+        .end((err, res) => {
+          if (err) {
+            return done(err);
+          }
+          expect(res).to.have.status(201);
+          expect(res.body).to.be.an("object");
+          expect(res.body.message).to.equal("Role created successfully!");
+          expect(res.body).to.have.property("id");
+          expect(fetchStub.calledOnce).to.equal(true);
+          const fetchCall = fetchStub.getCall(0);
+          const requestBody = JSON.parse(fetchCall.args[1].body);
+          expect(requestBody.rolename).to.equal("group-developers");
+
+          return done();
+        });
+    });
+
+    it("should create a group role with 'group-' prefix when role=false", function (done) {
+      const roleData = {
+        rolename: "developers",
+        description: "Test group role",
+      };
+
+      chai
+        .request(app)
+        .post("/discord-actions/groups?role=false")
+        .set("cookie", `${cookieName}=${testUserAuthToken}`)
+        .send(roleData)
+        .end((err, res) => {
+          if (err) {
+            return done(err);
+          }
+          expect(res).to.have.status(201);
+          expect(res.body).to.be.an("object");
+          expect(res.body.message).to.equal("Role created successfully!");
+          const fetchCall = fetchStub.getCall(0);
+          const requestBody = JSON.parse(fetchCall.args[1].body);
+          expect(requestBody.rolename).to.equal("group-developers");
+
+          return done();
+        });
+    });
+
+    it("should create a custom role without prefix when role=true", function (done) {
+      const roleData = {
+        rolename: "developers",
+        description: "Test custom role",
+      };
+
+      chai
+        .request(app)
+        .post("/discord-actions/groups?role=true")
+        .set("cookie", `${cookieName}=${testUserAuthToken}`)
+        .send(roleData)
+        .end((err, res) => {
+          if (err) {
+            return done(err);
+          }
+          expect(res).to.have.status(201);
+          expect(res.body).to.be.an("object");
+          expect(res.body.message).to.equal("Role created successfully!");
+          const fetchCall = fetchStub.getCall(0);
+          const requestBody = JSON.parse(fetchCall.args[1].body);
+          expect(requestBody.rolename).to.equal("developers");
+
+          return done();
+        });
+    });
+
+    it("should return 400 when role query param is not a boolean", function (done) {
+      const roleData = {
+        rolename: "developers",
+        description: "Test role",
+      };
+
+      chai
+        .request(app)
+        .post("/discord-actions/groups?role=invalid")
+        .set("cookie", `${cookieName}=${testUserAuthToken}`)
+        .send(roleData)
+        .end((err, res) => {
+          if (err) {
+            return done(err);
+          }
+          expect(res).to.have.status(400);
+          expect(res.body).to.be.an("object");
+          expect(res.body.error).to.equal("Bad Request");
+
+          return done();
+        });
+    });
+
+    it("should return 400 when role already exists", function (done) {
+      sinon.restore();
+      fetchStub = sinon.stub(global, "fetch");
+      fetchStub.returns(
+        Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve({ id: "discord-role-id-123" }),
+        })
+      );
+
+      sinon.stub(discordRolesModel, "isGroupRoleExists").resolves({
+        roleExists: true,
+      });
+
+      const roleData = {
+        rolename: "developers",
+        description: "Test role",
+      };
+
+      chai
+        .request(app)
+        .post("/discord-actions/groups?role=true")
+        .set("cookie", `${cookieName}=${testUserAuthToken}`)
+        .send(roleData)
+        .end((err, res) => {
+          if (err) {
+            return done(err);
+          }
+          expect(res).to.have.status(400);
+          expect(res.body).to.be.an("object");
+          expect(res.body.message).to.equal("Role already exists!");
+
+          return done();
+        });
+    });
+
+    it("should handle string 'true' as true boolean value", function (done) {
+      const roleData = {
+        rolename: "testrole",
+        description: "Test role",
+      };
+
+      chai
+        .request(app)
+        .post("/discord-actions/groups?role=true")
+        .set("cookie", `${cookieName}=${testUserAuthToken}`)
+        .send(roleData)
+        .end((err, res) => {
+          if (err) {
+            return done(err);
+          }
+          expect(res).to.have.status(201);
+          const fetchCall = fetchStub.getCall(0);
+          const requestBody = JSON.parse(fetchCall.args[1].body);
+          expect(requestBody.rolename).to.equal("testrole");
+
+          return done();
+        });
+    });
+  });
 });