Dev to Main Sync (#1357)

* Feat : username and twitter id contains @ / special characters  in the value in some user data. (#1320)

* feat:add validations in the signup api to check that username must be in the specific format and social id must not contain the special character @ to it also modify the error with a proper error message

* fix:the error message description

* fix:change the error message according to specific social id change

* fix:change the regex validation such that now it will accept numbers or characters or combination of both

* refactor:change the error message to meaningful text

* feat:add tests for invalid username and valid username and invalid social id

* fix:match the error message with the failing test case message, update the error messages in the signup api

* fix:remove unnecessary validation for linkedin_id, intagram_id we are not sending it during signup also remove the tests for that

* fix:remove unnecessary validation for linkedin_id, intagram_id we are not sending it during signup also remove the tests for that

* feat:add unit testing for the update user function to check if invalid username and twitter_id is passed or not

---------

Co-authored-by: pushpendu <[email protected]>

* add option to set privilaged roles in staging backend

* remove console logs

* modify the condition to check non production env

* add support to other roles update in staging (#1354)

* add support to other roles

* modify condition to forbid in production

* add an api to remove privilaged roles to all users (#1355)

* add an api to remove privilaged roles to all users

* add middleware to allow body

* adds metrics for users update route (#1347)

* Fixing Task Reassignment Status Update Issue (#1351)

* adds the logic to modify the user status of old assignee

* Adds integration test

* Consolidated Multi-Line Variable Declarations into Single Line

---------

Co-authored-by: Abhay Patil <[email protected]>
Co-authored-by: pushpendu <[email protected]>
Co-authored-by: ritikjaiswal75 <[email protected]>
Co-authored-by: Amit Prakash <[email protected]>
Co-authored-by: Ritik Jaiswal <[email protected]>

Author: 5 people

controllers/staging.js

@@ -0,0 +1,86 @@
+const { addOrUpdate, getUsersByRole } = require("../models/users");
+
+const updateRoles = async (req, res) => {
+  try {
+    const userData = await req.userData;
+    if (process.env.NODE_ENV === "production") {
+      return res.status(403).json({
+        message: "FORBIDDEN | To be used only in staging and development",
+      });
+    }
+    const userId = req.userData.id;
+    await addOrUpdate(
+      {
+        roles: {
+          ...userData.roles,
+          ...req.body,
+        },
+      },
+      userId
+    );
+    return res.status(200).json({
+      message: "Roles Updated successfully",
+    });
+  } catch (err) {
+    logger.error(`Oops an error occured: ${err}`);
+    return res.status(500).json({
+      message: "Oops an internal error occured",
+    });
+  }
+};
+
+const removePrivileges = async (req, res) => {
+  if (process.env.NODE_ENV === "production") {
+    return res.status(403).json({
+      message: "FORBIDDEN | To be used only in staging and development",
+    });
+  }
+  try {
+    const updateUserPromises = [];
+    const members = await getUsersByRole("member");
+    const superUsers = await getUsersByRole("super_user");
+
+    members.forEach((member) => {
+      updateUserPromises.push(
+        addOrUpdate(
+          {
+            roles: {
+              ...member.roles,
+              member: false,
+            },
+          },
+          member.id
+        )
+      );
+    });
+    superUsers.forEach((superUser) => {
+      updateUserPromises.push(
+        addOrUpdate(
+          {
+            roles: {
+              ...superUser.roles,
+              super_user: false,
+            },
+          },
+          superUser.id
+        )
+      );
+    });
+
+    await Promise.all(updateUserPromises);
+
+    return res.status(200).json({
+      message: "Roles Updated successfully",
+    });
+  } catch (err) {
+    logger.error(`Oops an error occurred: ${err}`);
+    return res.status(500).json({
+      message: "Oops an internal error occurred",
+    });
+  }
+};
+
+module.exports = {
+  updateRoles,
+  removePrivileges,
+};

controllers/tasks.js

@@ -256,7 +256,12 @@ const updateTask = async (req, res) => {
     }
     await tasks.updateTask(req.body, req.params.id);
     if (isUserStatusEnabled && req.body.assignee) {
+      // New Assignee Status Update
       await updateUserStatusOnTaskUpdate(req.body.assignee);
+      // Old Assignee Status Update if available
+      if (task.taskData.assigneeId) {
+        await updateStatusOnTaskCompletion(task.taskData.assigneeId);
+      }
     }
 
     return res.status(204).send();

controllers/userStatus.js

@@ -135,9 +135,10 @@ const updateUserStatus = async (req, res) => {
  */
 const updateAllUserStatus = async (req, res) => {
   try {
-    await userStatusModel.updateAllUserStatus();
+    const data = await userStatusModel.updateAllUserStatus();
     return res.status(200).json({
       message: "All User Status updated successfully.",
+      data,
     });
   } catch (err) {
     logger.error(`Error while updating the User Data: ${err}`);

middlewares/validators/staging.js

@@ -0,0 +1,39 @@
+const joi = require("joi");
+
+const validateUserRoles = async (req, res, next) => {
+  const schema = joi.object().strict().keys({
+    super_user: joi.boolean().optional(),
+    member: joi.boolean().optional(),
+    archive: joi.boolean().optional(),
+    in_discord: joi.boolean().optional(),
+  });
+
+  try {
+    await schema.validateAsync(req.body);
+    next();
+  } catch (err) {
+    logger.error(`Error validating validateUserRoles payload : ${err}`);
+    res.boom.badRequest(JSON.stringify({ allowedParameters: { super_user: "boolean", member: "boolean" } }));
+  }
+};
+
+const validateRevokePrivileges = async (req, res, next) => {
+  const schema = joi
+    .object()
+    .strict()
+    .keys({
+      action: joi.string().equal("revoke"),
+    });
+  try {
+    await schema.validateAsync(req.body);
+    next();
+  } catch (err) {
+    logger.error(`Error validating validateUserRoles payload : ${err}`);
+    res.boom.badRequest(JSON.stringify({ allowedParameters: { action: "revoke" } }));
+  }
+};
+
+module.exports = {
+  validateUserRoles,
+  validateRevokePrivileges,
+};

middlewares/validators/user.js

@@ -13,15 +13,25 @@ const updateUser = async (req, res, next) => {
     .keys({
       phone: joi.string().optional(),
       email: joi.string().optional(),
-      username: joi.string().optional(),
+      username: joi
+        .string()
+        .optional()
+        .min(4)
+        .max(20)
+        .regex(/^[a-zA-Z0-9]+$/)
+        .message("Username must be between 4 and 20 characters long and contain only letters or numbers."),
       first_name: joi.string().optional(),
       last_name: joi.string().optional(),
       yoe: joi.number().min(0).optional(),
       company: joi.string().optional(),
       designation: joi.string().optional(),
       img: joi.string().optional(),
       linkedin_id: joi.string().optional(),
-      twitter_id: joi.string().optional(),
+      twitter_id: joi
+        .string()
+        .optional()
+        .regex(/^[^@]*$/)
+        .message("Invalid Twitter ID. ID should not contain special character @"),
       instagram_id: joi.string().optional(),
       website: joi.string().optional(),
       status: joi

models/userStatus.js

@@ -157,8 +157,16 @@ const updateUserStatus = async (userId, newStatusData) => {
  */
 
 const updateAllUserStatus = async () => {
+  const summary = {
+    usersCount: 0,
+    oooUsersAltered: 0,
+    oooUsersUnaltered: 0,
+    nonOooUsersAltered: 0,
+    nonOooUsersUnaltered: 0,
+  };
   try {
     const userStatusDocs = await userStatusModel.where("futureStatus.state", "in", ["ACTIVE", "IDLE", "OOO"]).get();
+    summary.usersCount = userStatusDocs._size;
     const batch = firestore.batch();
     const today = new Date().getTime();
     userStatusDocs.forEach(async (document) => {
@@ -170,15 +178,23 @@ const updateAllUserStatus = async () => {
       const { state: futureState } = futureStatus;
       if (futureState === "ACTIVE" || futureState === "IDLE") {
         if (today >= futureStatus.from) {
+          // OOO period is over and we need to update their current status
           newStatusData.currentStatus = { ...futureStatus, until: "", updatedAt: today };
-          newStatusData.futureStatus = {};
+          delete newStatusData.futureStatus;
           toUpdate = !toUpdate;
+          summary.oooUsersAltered++;
+        } else {
+          summary.oooUsersUnaltered++;
         }
       } else {
+        // futureState is OOO
         if (today > futureStatus.until) {
-          newStatusData.futureStatus = {};
+          // the OOO period is over
+          delete newStatusData.futureStatus;
           toUpdate = !toUpdate;
+          summary.nonOooUsersAltered++;
         } else if (today <= doc.futureStatus.until && today >= doc.futureStatus.from) {
+          // the current date i.e today lies in between the from and until so we need to swap the status
           let newCurrentStatus = {};
           let newFutureStatus = {};
           newCurrentStatus = { ...futureStatus, updatedAt: today };
@@ -188,6 +204,9 @@ const updateAllUserStatus = async () => {
           newStatusData.currentStatus = newCurrentStatus;
           newStatusData.futureStatus = newFutureStatus;
           toUpdate = !toUpdate;
+          summary.nonOooUsersAltered++;
+        } else {
+          summary.nonOooUsersUnaltered++;
         }
       }
       if (toUpdate) {
@@ -200,13 +219,12 @@ const updateAllUserStatus = async () => {
       );
     }
     await batch.commit();
-    return { status: 204, message: "User Status updated Successfully." };
+    return summary;
   } catch (error) {
     logger.error(`error in updating User Status Documents ${error}`);
     return { status: 500, message: "User Status couldn't be updated Successfully." };
   }
 };
-
 /**
  * Updates the user status based on a new task assignment.
  * @param {string} userId - The ID of the user.

routes/index.js

@@ -30,5 +30,5 @@ app.use("/discord-actions", require("./discordactions.js"));
 app.use("/issues", require("./issues.js"));
 app.use("/progresses", require("./progresses.js"));
 app.use("/monitor", require("./monitor.js"));
-
+app.use("/staging", require("./staging.js"));
 module.exports = app;

routes/staging.js

@@ -0,0 +1,10 @@
+const express = require("express");
+const authenticate = require("../middlewares/authenticate");
+const { validateUserRoles, validateRevokePrivileges } = require("../middlewares/validators/staging");
+const { updateRoles, removePrivileges } = require("../controllers/staging");
+const router = express.Router();
+
+router.patch("/user", validateUserRoles, authenticate, updateRoles);
+router.post("/users/privileges", validateRevokePrivileges, removePrivileges);
+
+module.exports = router;

test/integration/taskBasedStatusUpdate.test.js

@@ -537,4 +537,59 @@ describe("Task Based Status Updates", function () {
       );
     });
   });
+
+  describe("PATCH Update User Status on Task Assignment by SuperUser", function () {
+    let userId1, user2Name, superUserId, superUserJwt, taskArr;
+    const reqBody = {};
+
+    beforeEach(async function () {
+      userId1 = await addUser(userData[6]);
+      superUserId = await addUser(userData[4]);
+      superUserJwt = authService.generateAuthToken({ userId: superUserId });
+      await addUser(userData[0]);
+      user2Name = userData[0].username;
+      taskArr = allTasks();
+      const sampleTask1 = taskArr[0];
+      sampleTask1.assignee = userId1;
+      sampleTask1.createdBy = superUserId;
+      await firestore.collection("tasks").doc("taskid123").set(sampleTask1);
+      const statusData = generateStatusDataForState(userId1, userState.ACTIVE);
+      await firestore.collection("usersStatus").doc("userStatusDoc001").set(statusData);
+    });
+
+    afterEach(async function () {
+      await cleanDb();
+    });
+
+    it("Update the old assignee status to IDLE on task reassignment if no tasks is in progress in their name", async function () {
+      reqBody.assignee = user2Name;
+      const res = await chai
+        .request(app)
+        .patch(`/tasks/taskid123?userStatusFlag=true`)
+        .set("cookie", `${cookieName}=${superUserJwt}`)
+        .send(reqBody);
+      expect(res.status).to.equal(204);
+      const userStatus002Data = (await userStatusModel.doc("userStatusDoc001").get()).data();
+      expect(userStatus002Data).to.have.keys(["userId", "currentStatus"]);
+      expect(userStatus002Data.currentStatus.state).to.equal(userState.IDLE);
+    });
+
+    it("Should maintain the old assignee status to ACTIVE on task reassignment if another task is in progress in their name", async function () {
+      const sampleTask2 = taskArr[1];
+      sampleTask2.assignee = userId1;
+      sampleTask2.createdBy = superUserId;
+      await firestore.collection("tasks").doc("taskid234").set(sampleTask2);
+
+      reqBody.assignee = user2Name;
+      const res = await chai
+        .request(app)
+        .patch(`/tasks/taskid123?userStatusFlag=true`)
+        .set("cookie", `${cookieName}=${superUserJwt}`)
+        .send(reqBody);
+      expect(res.status).to.equal(204);
+      const userStatus002Data = (await userStatusModel.doc("userStatusDoc001").get()).data();
+      expect(userStatus002Data).to.have.keys(["userId", "currentStatus"]);
+      expect(userStatus002Data.currentStatus.state).to.equal(userState.ACTIVE);
+    });
+  });
 });

test/integration/userStatus.test.js

@@ -175,6 +175,13 @@ describe("UserStatus", function () {
         .send();
       expect(response3).to.have.status(200);
       expect(response3.body.message).to.equal("All User Status updated successfully.");
+      expect(response3.body.data).to.deep.equal({
+        usersCount: 1,
+        oooUsersAltered: 0,
+        oooUsersUnaltered: 0,
+        nonOooUsersAltered: 1,
+        nonOooUsersUnaltered: 0,
+      });
 
       // Checking the current status
       const response4 = await chai.request(app).get(`/users/status/self`).set("Cookie", `${cookieName}=${testUserJwt}`);
@@ -195,6 +202,13 @@ describe("UserStatus", function () {
         .send();
       expect(response5).to.have.status(200);
       expect(response5.body.message).to.equal("All User Status updated successfully.");
+      expect(response5.body.data).to.deep.equal({
+        usersCount: 1,
+        oooUsersAltered: 1,
+        oooUsersUnaltered: 0,
+        nonOooUsersAltered: 0,
+        nonOooUsersUnaltered: 0,
+      });
 
       const response6 = await chai.request(app).get(`/users/status/self`).set("Cookie", `${cookieName}=${testUserJwt}`);
       expect(response6).to.have.status(200);
@@ -236,6 +250,13 @@ describe("UserStatus", function () {
         .send();
       expect(response3).to.have.status(200);
       expect(response3.body.message).to.equal("All User Status updated successfully.");
+      expect(response3.body.data).to.deep.equal({
+        usersCount: 1,
+        oooUsersAltered: 0,
+        oooUsersUnaltered: 0,
+        nonOooUsersAltered: 1,
+        nonOooUsersUnaltered: 0,
+      });
 
       // Checking the current status
       const response4 = await chai.request(app).get(`/users/status/self`).set("Cookie", `${cookieName}=${testUserJwt}`);