Merge branch 'develop' into feat/issue1314

Author: mailmesriza98

controllers/discordactions.js

@@ -3,6 +3,7 @@ const admin = require("firebase-admin");
 const config = require("config");
 const jwt = require("jsonwebtoken");
 const discordRolesModel = require("../models/discordactions");
+const { retrieveUsers } = require("../services/dataAccessLayer");
 
 /**
  * Creates a role
@@ -66,9 +67,25 @@ const createGroupRole = async (req, res) => {
 const getAllGroupRoles = async (req, res) => {
   try {
     const { groups } = await discordRolesModel.getAllGroupRoles();
+    const groupsWithMemberCount = await discordRolesModel.getNumberOfMemberForGroups(groups);
+    const groupCreatorIds = groupsWithMemberCount.reduce((ids, group) => {
+      ids.add(group.createdBy);
+      return ids;
+    }, new Set());
+    const groupCreatorsDetails = await retrieveUsers({ userIds: Array.from(groupCreatorIds) });
+    const groupsWithUserDetails = groupsWithMemberCount.map((group) => {
+      const groupCreator = groupCreatorsDetails[group.createdBy];
+      return {
+        ...group,
+        firstName: groupCreator.first_name,
+        lastName: groupCreator.last_name,
+        image: groupCreator.picture?.url,
+      };
+    });
+
     return res.json({
       message: "Roles fetched successfully!",
-      groups,
+      groups: groupsWithUserDetails,
     });
   } catch (err) {
     logger.error(`Error while getting roles: ${err}`);

controllers/issues.js

@@ -25,6 +25,7 @@ const getIssues = async (req, res) => {
       const taskData = await tasks.fetchTaskByIssueId(issue.id);
       if (taskData) {
         issue.taskExists = true;
+        issue.taskId = taskData.id;
       }
 
       return issue;

models/discordactions.js

@@ -114,10 +114,41 @@ const updateDiscordImageForVerification = async (userDiscordId) => {
   }
 };
 
+const getNumberOfMemberForGroups = async (groups = []) => {
+  try {
+    if (!groups.length) {
+      return [];
+    }
+    const roleIds = groups.map((group) => group.roleid);
+
+    const snapshots = await memberRoleModel.where("roleid", "in", roleIds).get();
+    const roleCount = {};
+
+    snapshots.forEach((doc) => {
+      const roleToMemberMapping = doc.data();
+
+      if (roleCount[roleToMemberMapping.roleid]) {
+        roleCount[roleToMemberMapping.roleid] += 1;
+      } else {
+        roleCount[roleToMemberMapping.roleid] = 1;
+      }
+    });
+
+    return groups.map((group) => ({
+      ...group,
+      memberCount: roleCount[group.roleid] || 0,
+    }));
+  } catch (err) {
+    logger.error("Error while counting members for each group", err);
+    throw err;
+  }
+};
+
 module.exports = {
   createNewRole,
   getAllGroupRoles,
   addGroupRoleToMember,
   isGroupRoleExists,
   updateDiscordImageForVerification,
+  getNumberOfMemberForGroups,
 };

models/userStatus.js

@@ -11,6 +11,7 @@ const {
   checkIfUserHasLiveTasks,
   generateErrorResponse,
   generateNewStatus,
+  getNextDayTimeStamp,
 } = require("../utils/userStatus");
 const { TASK_STATUS } = require("../constants/tasks");
 const userStatusModel = firestore.collection("usersStatus");
@@ -371,7 +372,7 @@ const batchUpdateUsersStatus = async (users) => {
     const statusToUpdate = {
       state,
       message: "",
-      from: currentTimeStamp,
+      from: new Date().setUTCHours(0, 0, 0, 0),
       until: "",
       updatedAt: currentTimeStamp,
     };
@@ -391,8 +392,7 @@ const batchUpdateUsersStatus = async (users) => {
       if (currentState === state) {
         currentState === userState.ACTIVE ? summary.activeUsersUnaltered++ : summary.idleUsersUnaltered++;
         continue;
-      }
-      if (currentState === userState.ONBOARDING) {
+      } else if (currentState === userState.ONBOARDING) {
         const docRef = userStatusModel.doc(id);
         if (state === userState.ACTIVE) {
           const updatedStatusData = {
@@ -403,20 +403,35 @@ const batchUpdateUsersStatus = async (users) => {
         } else {
           summary.onboardingUsersUnaltered++;
         }
-      } else {
+      } else if (currentState === userState.OOO) {
+        const docRef = userStatusModel.doc(id);
         state === userState.ACTIVE ? summary.activeUsersAltered++ : summary.idleUsersAltered++;
+
+        const currentDate = new Date();
+        const untilDate = new Date(until);
+
+        const timeDifferenceMilliseconds = currentDate.setUTCHours(0, 0, 0, 0) - untilDate.setUTCHours(0, 0, 0, 0);
+        const timeDifferenceDays = Math.floor(timeDifferenceMilliseconds / (24 * 60 * 60 * 1000));
+
+        if (timeDifferenceDays >= 1) {
+          batch.update(docRef, {
+            currentStatus: statusToUpdate,
+          });
+        } else {
+          const getNextDayAfterUntil = getNextDayTimeStamp(until);
+          batch.update(docRef, {
+            futureStatus: {
+              ...statusToUpdate,
+              from: getNextDayAfterUntil,
+            },
+          });
+        }
+      } else {
         const docRef = userStatusModel.doc(id);
-        const updatedStatusData =
-          currentState === userState.OOO
-            ? {
-                futureStatus: {
-                  ...statusToUpdate,
-                  from: until,
-                },
-              }
-            : {
-                currentStatus: statusToUpdate,
-              };
+        state === userState.ACTIVE ? summary.activeUsersAltered++ : summary.idleUsersAltered++;
+        const updatedStatusData = {
+          currentStatus: statusToUpdate,
+        };
         batch.update(docRef, updatedStatusData);
       }
     }

models/users.js

@@ -584,6 +584,31 @@ const fetchUsersWithToken = async () => {
     return users;
   } catch (err) {
     logger.error(`Error while fetching all users with tokens field: ${err}`);
+    return [];
+  }
+};
+/**
+ *
+ * @param {[string]} userIds  Array id's of user
+ * @returns Object containing the details of the users whose userId was provided.
+ */
+const fetchUserByIds = async (userIds = []) => {
+  if (userIds.length === 0) {
+    return {};
+  }
+  try {
+    const users = {};
+    const usersRefs = userIds.map((docId) => userModel.doc(docId));
+    const documents = await firestore.getAll(...usersRefs);
+    documents.forEach((snapshot) => {
+      if (snapshot.exists) {
+        users[snapshot.id] = snapshot.data();
+      }
+    });
+
+    return users;
+  } catch (err) {
+    logger.error("Error retrieving user data", err);
     throw err;
   }
 };
@@ -666,4 +691,5 @@ module.exports = {
   fetchUsersWithToken,
   removeGitHubToken,
   getUsersByRole,
+  fetchUserByIds,
 };

services/dataAccessLayer.js

@@ -10,6 +10,7 @@ const retrieveUsers = async ({
   userdata,
   level = ACCESS_LEVEL.PUBLIC,
   role = null,
+  userIds = [],
 }) => {
   if (id || username) {
     let result;
@@ -29,6 +30,12 @@ const retrieveUsers = async ({
       result.push(user);
     });
     return result;
+  } else if (userIds.length > 0) {
+    const userDetails = await userQuery.fetchUserByIds(userIds);
+    Object.keys(userDetails).forEach((userId) => {
+      removeSensitiveInfo(userDetails[userId]);
+    });
+    return userDetails;
   } else if (query) {
     const { allUsers, nextId, prevId } = await userQuery.fetchPaginatedUsers(query);
     const users = [];

test/fixtures/discordactions/discordactions.js

@@ -1,7 +1,7 @@
 const groupData = [
-  { id: "1", name: "Group 1" },
-  { id: "2", name: "Group 2" },
-  { id: "3", name: "Group 3" },
+  { rolename: "Group 1", roleid: 1 },
+  { rolename: "Group 2", roleid: 2 },
+  { rolename: "Group 3", roleid: 3 },
 ];
 
 const roleData = {

test/integration/discord.test.js

@@ -8,6 +8,14 @@ const authService = require("../../services/authService");
 const userData = require("../fixtures/user/user")();
 const { requestRoleData } = require("../fixtures/discordactions/discordactions");
 
+const firestore = require("../../utils/firestore");
+const discordRoleModel = firestore.collection("discord-roles");
+const userModel = firestore.collection("users");
+
+const { addGroupRoleToMember } = require("../../models/discordactions");
+
+const { groupData } = require("../fixtures/discordactions/discordactions");
+
 const cookieName = config.get("userToken.cookieName");
 
 let userId;
@@ -59,6 +67,29 @@ describe("test discord actions", function () {
       const user = { ...userData[4], discordId: "123456789" };
       userId = await addUser(user);
       jwt = authService.generateAuthToken({ userId });
+
+      let allIds = [];
+
+      const addUsersPromises = userData.map((user) => userModel.add({ ...user }));
+      const responses = await Promise.all(addUsersPromises);
+      allIds = responses.map((response) => response.id);
+
+      const addRolesPromises = [
+        discordRoleModel.add({ roleid: groupData[0].roleid, rolename: groupData[0].rolename, createdBy: allIds[1] }),
+        discordRoleModel.add({ roleid: groupData[1].roleid, rolename: groupData[1].rolename, createdBy: allIds[0] }),
+      ];
+      await Promise.all(addRolesPromises);
+
+      const addGroupRolesPromises = [
+        addGroupRoleToMember({ roleid: groupData[0].roleid, userid: allIds[0] }),
+        addGroupRoleToMember({ roleid: groupData[0].roleid, userid: allIds[1] }),
+        addGroupRoleToMember({ roleid: groupData[0].roleid, userid: allIds[1] }),
+        addGroupRoleToMember({ roleid: groupData[1].roleid, userid: allIds[0] }),
+      ];
+      await Promise.all(addGroupRolesPromises);
+    });
+    afterEach(async function () {
+      await cleanDb();
     });
 
     it("returns 200 for active users get method", function (done) {

test/integration/discordactions.test.js

@@ -16,6 +16,11 @@ const cookieName = config.get("userToken.cookieName");
 const firestore = require("../../utils/firestore");
 const { userPhotoVerificationData } = require("../fixtures/user/photo-verification");
 const photoVerificationModel = firestore.collection("photo-verification");
+const discordRoleModel = firestore.collection("discord-roles");
+const userModel = firestore.collection("users");
+
+const { groupData } = require("../fixtures/discordactions/discordactions");
+const { addGroupRoleToMember } = require("../../models/discordactions");
 chai.use(chaiHttp);
 
 describe("Discord actions", function () {
@@ -85,4 +90,54 @@ describe("Discord actions", function () {
         });
     });
   });
+
+  describe("GET /discord-actions/groups", function () {
+    before(async function () {
+      let allIds = [];
+
+      const addUsersPromises = userData.map((user) => userModel.add({ ...user }));
+      const responses = await Promise.all(addUsersPromises);
+      allIds = responses.map((response) => response.id);
+
+      const addRolesPromises = [
+        discordRoleModel.add({ roleid: groupData[0].roleid, rolename: groupData[0].rolename, createdBy: allIds[1] }),
+        discordRoleModel.add({ roleid: groupData[1].roleid, rolename: groupData[1].rolename, createdBy: allIds[0] }),
+      ];
+      await Promise.all(addRolesPromises);
+
+      const addGroupRolesPromises = [
+        addGroupRoleToMember({ roleid: groupData[0].roleid, userid: allIds[0] }),
+        addGroupRoleToMember({ roleid: groupData[0].roleid, userid: allIds[1] }),
+        addGroupRoleToMember({ roleid: groupData[0].roleid, userid: allIds[1] }),
+        addGroupRoleToMember({ roleid: groupData[1].roleid, userid: allIds[0] }),
+      ];
+      await Promise.all(addGroupRolesPromises);
+    });
+
+    after(async function () {
+      await cleanDb();
+    });
+
+    it("should successfully return all groups detail", function (done) {
+      chai
+        .request(app)
+        .get(`/discord-actions/groups`)
+        .set("cookie", `${cookieName}=${superUserAuthToken}`)
+        .end((err, res) => {
+          if (err) {
+            return done(err);
+          }
+
+          expect(res).to.have.status(200);
+          expect(res.body).to.be.an("object");
+          // Verify presence of specific properties in each group
+          const expectedProps = ["roleid", "rolename", "memberCount", "firstName", "lastName", "image"];
+          res.body.groups.forEach((group) => {
+            expect(group).to.include.all.keys(expectedProps);
+          });
+          expect(res.body.message).to.equal("Roles fetched successfully!");
+          return done();
+        });
+    });
+  });
 });