Merge pull request #1309 from bksh05/feature/add-data-in-groups-api

Added member count and creator details in the GET discord-actions/groups API.

Author: iamitprakash

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}`);

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/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

@@ -2,7 +2,14 @@ const userQuery = require("../models/users");
 const members = require("../models/members");
 const { USER_SENSITIVE_DATA } = require("../constants/users");
 
-const retrieveUsers = async ({ id = null, username = null, usernames = null, query = null, userdata }) => {
+const retrieveUsers = async ({
+  id = null,
+  username = null,
+  usernames = null,
+  query = null,
+  userdata,
+  userIds = [],
+}) => {
   if (id || username) {
     let result;
     if (id != null) {
@@ -18,6 +25,14 @@ const retrieveUsers = async ({ id = null, username = null, usernames = null, que
       removeSensitiveInfo(element);
     });
     return users;
+  } 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);
     allUsers.forEach((element) => {

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();
+        });
+    });
+  });
 });

test/unit/models/discordactions.test.js

@@ -12,6 +12,7 @@ const {
   isGroupRoleExists,
   addGroupRoleToMember,
   updateDiscordImageForVerification,
+  getNumberOfMemberForGroups,
 } = require("../../../models/discordactions");
 const { groupData, roleData, existingRole } = require("../../fixtures/discordactions/discordactions");
 const cleanDb = require("../../utils/cleanDb");
@@ -243,4 +244,40 @@ describe("discordactions", function () {
       }
     });
   });
+
+  describe("getNumberOfMemberForGroups", function () {
+    before(async function () {
+      await Promise.all([
+        addGroupRoleToMember({ roleid: groupData[0].roleid, userid: 1 }),
+        addGroupRoleToMember({ roleid: groupData[0].roleid, userid: 2 }),
+        addGroupRoleToMember({ roleid: groupData[0].roleid, userid: 3 }),
+        addGroupRoleToMember({ roleid: groupData[1].roleid, userid: 1 }),
+      ]);
+    });
+
+    after(async function () {
+      await cleanDb();
+    });
+
+    it("should return an empty array if the parameter is an empty array", async function () {
+      const result = await getNumberOfMemberForGroups([]);
+      expect(result).to.be.an("array");
+      expect(result.length).to.equal(0);
+    });
+
+    it("should return an empty array if the parameter no parameter is passed", async function () {
+      const result = await getNumberOfMemberForGroups();
+      expect(result).to.be.an("array");
+      expect(result.length).to.equal(0);
+    });
+
+    it("should return group details with memberCount details ", async function () {
+      const result = await getNumberOfMemberForGroups(groupData);
+      expect(result).to.deep.equal([
+        { rolename: groupData[0].rolename, roleid: 1, memberCount: 3 },
+        { rolename: groupData[1].rolename, roleid: 2, memberCount: 1 },
+        { rolename: groupData[2].rolename, roleid: 3, memberCount: 0 },
+      ]);
+    });
+  });
 });

test/unit/models/users.test.js

@@ -290,4 +290,32 @@ describe("users", function () {
       });
     });
   });
+  describe("fetch users by id", function () {
+    let allIds = [];
+    before(async function () {
+      const addUsersPromises = [];
+      userDataArray.forEach((user, index) => {
+        addUsersPromises.push(userModel.add({ ...user }));
+      });
+      const responses = await Promise.all(addUsersPromises);
+      allIds = responses.map((response) => response.id);
+    });
+
+    after(async function () {
+      await cleanDb();
+    });
+
+    it("should fetch the details of users whose ids are present in the array", async function () {
+      const randomIds = allIds.sort(() => 0.5 - Math.random()).slice(0, 3); // Select random ids from allIds
+      const result = await users.fetchUserByIds(randomIds);
+      const fetchedUserIds = Object.keys(result);
+      expect(fetchedUserIds).to.deep.equal(randomIds);
+    });
+
+    it("should return empty object if no ids are passed", async function () {
+      const result = await users.fetchUserByIds();
+      const fetchedUserIds = Object.keys(result);
+      expect(fetchedUserIds).to.deep.equal([]);
+    });
+  });
 });

test/unit/services/dataAccessLayer.test.js

@@ -121,6 +121,19 @@ describe("Data Access Layer", function () {
         });
       });
     });
+
+    it("should fetch multiple users details based on ids and remove sensitive data", async function () {
+      const fetchUserStub = sinon.stub(userQuery, "fetchUserByIds");
+      fetchUserStub.returns(Promise.resolve({ [userData[12].id]: userData[12] }));
+      const result = await retrieveUsers({ userIds: [userData[12].id] });
+      removeSensitiveInfo(userData[12]);
+      Object.keys(result).forEach((id) => {
+        expect(result[id]).to.deep.equal(userData[12]);
+        USER_SENSITIVE_DATA.forEach((key) => {
+          expect(result[id]).to.not.have.property(key);
+        });
+      });
+    });
   });
 
   describe("retrieveFilteredUsers", function () {