Merge branch 'develop' of https://github.com/Real-Dev-Squad/website-backend into develop

Author: shubham-y

.github/workflows/test.yml

@@ -6,16 +6,15 @@ name: Tests
 on:
   pull_request:
     branches:
-      - '**'
+      - "**"
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
 
     strategy:
       matrix:
-        node-version: [14.x]
+        node-version: [18.x]
 
     steps:
     - uses: actions/checkout@v3

constants/firebase.js

@@ -0,0 +1,5 @@
+const BATCH_SIZE_IN_CLAUSE = 30; // since only 30 comparision values are allowed in 'in' clause
+
+module.exports = {
+  BATCH_SIZE_IN_CLAUSE,
+};

constants/users.js

@@ -10,4 +10,9 @@ const USER_STATUS = {
   ACTIVE: "active",
 };
 
-module.exports = { profileStatus, USER_STATUS };
+const ALLOWED_FILTER_PARAMS = {
+  ITEM_TAG: ["levelId", "levelName", "levelValue", "tagId"],
+  USER_STATE: ["state"],
+};
+
+module.exports = { profileStatus, USER_STATUS, ALLOWED_FILTER_PARAMS };

controllers/pullRequests.js

@@ -1,5 +1,6 @@
 const githubService = require("../services/githubService");
 const { SOMETHING_WENT_WRONG } = require("../constants/errorMessages");
+const { ORDER_TYPE } = require("../utils/pullRequests");
 
 /**
  * Collects all pull requests and sends only required data for each pull request
@@ -38,8 +39,9 @@ const getUserPRs = async (req, res) => {
  */
 const getStalePRs = async (req, res) => {
   try {
+    const order = ORDER_TYPE.ASC;
     const { size, page } = req.query;
-    const { data } = await githubService.fetchStalePRs(size, page);
+    const { data } = await githubService.fetchOpenPRs({ perPage: size, page, resultOptions: { order } });
 
     if (data.total_count) {
       const allPRs = githubService.extractPRdetails(data);
@@ -67,8 +69,9 @@ const getStalePRs = async (req, res) => {
  */
 const getOpenPRs = async (req, res) => {
   try {
+    const order = ORDER_TYPE.DESC;
     const { size, page } = req.query;
-    const { data } = await githubService.fetchOpenPRs(size, page);
+    const { data } = await githubService.fetchOpenPRs({ perPage: size, page, resultOptions: { order } });
 
     if (data.total_count) {
       const allPRs = githubService.extractPRdetails(data);

controllers/users.js

@@ -8,8 +8,10 @@ const { logType } = require("../constants/logs");
 const { fetch } = require("../utils/fetch");
 const logger = require("../utils/logger");
 const obfuscate = require("../utils/obfuscate");
-const { getPaginationLink } = require("../utils/users");
+const { getPaginationLink, getUsernamesFromPRs } = require("../utils/users");
+const { getQualifiers } = require("../utils/helper");
 const { SOMETHING_WENT_WRONG, INTERNAL_SERVER_ERROR } = require("../constants/errorMessages");
+const { getFilteredPRsOrIssues } = require("../utils/pullRequests");
 
 const verifyUser = async (req, res) => {
   const userId = req.userData.id;
@@ -65,7 +67,23 @@ const getUserById = async (req, res) => {
 
 const getUsers = async (req, res) => {
   try {
-    const { allUsers, nextId, prevId } = await userQuery.fetchUsers(req.query);
+    const query = req.query?.query ?? "";
+    const qualifiers = getQualifiers(query);
+
+    if (qualifiers?.filterBy) {
+      const allPRs = await getFilteredPRsOrIssues(qualifiers);
+
+      const filteredUsernames = getUsernamesFromPRs(allPRs);
+
+      const { filterdUsersWithDetails } = await userQuery.fetchUsers(filteredUsernames);
+
+      return res.json({
+        message: "Users returned successfully!",
+        users: filterdUsersWithDetails,
+      });
+    }
+
+    const { allUsers, nextId, prevId } = await userQuery.fetchPaginatedUsers(req.query);
 
     return res.json({
       message: "Users returned successfully!",
@@ -419,6 +437,31 @@ const addDefaultArchivedRole = async (req, res) => {
   }
 };
 
+/**
+ * Returns the lists of users who match the specified query params
+ *
+ * @param req {Object} - Express request object
+ * @param res {Object} - Express response object
+ */
+
+const filterUsers = async (req, res) => {
+  try {
+    if (!Object.keys(req.query).length) {
+      return res.boom.badRequest("filter for item not provided");
+    }
+    const allUsers = await userQuery.getUsersBasedOnFilter(req.query);
+
+    return res.json({
+      message: "Users found successfully!",
+      users: allUsers,
+      count: allUsers.length,
+    });
+  } catch (error) {
+    logger.error(`Error while fetching all users: ${error}`);
+    return res.boom.serverUnavailable("Something went wrong please contact admin");
+  }
+};
+
 module.exports = {
   verifyUser,
   generateChaincode,
@@ -437,4 +480,5 @@ module.exports = {
   getUserIntro,
   addDefaultArchivedRole,
   getUserSkills,
+  filterUsers,
 };

firebase.json

@@ -1,9 +1,11 @@
 {
   "emulators": {
     "firestore": {
+      "host": "0.0.0.0",
       "port": 8081
     },
     "ui": {
+      "host": "0.0.0.0",
       "enabled": true,
       "port": 4000
     }

middlewares/validators/user.js

@@ -137,6 +137,7 @@ async function getUsers(req, res, next) {
         .messages({
           "string.empty": "prev value cannot be empty",
         }),
+      query: joi.string().optional(),
     });
   try {
     await schema.validateAsync(req.query);
@@ -147,9 +148,45 @@ async function getUsers(req, res, next) {
   }
 }
 
+/**
+ * Validator function for query params for the filter route
+ *
+ * @param req {Object} - Express request object
+ * @param res {Object} - Express response object
+ * @param next {Object} - Express middleware function
+ */
+async function validateUserQueryParams(req, res, next) {
+  const schema = joi
+    .object()
+    .strict()
+    .min(1)
+    .keys({
+      levelId: joi.array().items(joi.string()).single().optional(),
+      levelName: joi.array().items(joi.string()).single().optional(),
+      levelValue: joi.array().items(joi.number()).single().optional(),
+      tagId: joi.array().items(joi.string()).single().optional(),
+      state: joi
+        .alternatives()
+        .try(
+          joi.string().valid("IDLE", "OOO", "ACTIVE"),
+          joi.array().items(joi.string().valid("IDLE", "OOO", "ACTIVE"))
+        )
+        .optional(),
+    });
+
+  try {
+    await schema.validateAsync(req.query);
+    next();
+  } catch (error) {
+    logger.error(`Error validating query params : ${error}`);
+    res.boom.badRequest(error.details[0].message);
+  }
+}
+
 module.exports = {
   updateUser,
   updateProfileURL,
   validateJoinData,
   getUsers,
+  validateUserQueryParams,
 };

models/users.js

@@ -6,10 +6,14 @@ const walletConstants = require("../constants/wallets");
 
 const firestore = require("../utils/firestore");
 const { fetchWallet, createWallet } = require("../models/wallets");
+const { arraysHaveCommonItem } = require("../utils/array");
+const { ALLOWED_FILTER_PARAMS } = require("../constants/users");
+const { BATCH_SIZE_IN_CLAUSE } = require("../constants/firebase");
 const userModel = firestore.collection("users");
 const joinModel = firestore.collection("applicants");
 const itemModel = firestore.collection("itemTags");
-
+const userStatusModel = firestore.collection("usersStatus");
+const { ITEM_TAG, USER_STATE } = ALLOWED_FILTER_PARAMS;
 /**
  * Adds or updates the user data
  *
@@ -126,7 +130,7 @@ const getSuggestedUsers = async (skill) => {
  * @param query { search, next, prev, size, page }: Filter for users
  * @return {Promise<userModel|Array>}
  */
-const fetchUsers = async (query) => {
+const fetchPaginatedUsers = async (query) => {
   try {
     // INFO: default user size set to 100
     // INFO: https://github.com/Real-Dev-Squad/website-backend/pull/873#discussion_r1064229932
@@ -175,6 +179,45 @@ const fetchUsers = async (query) => {
   }
 };
 
+const fetchUsers = async (usernames = []) => {
+  try {
+    const dbQuery = userModel;
+    const filterdUsersWithDetails = [];
+
+    const groups = [];
+    for (let i = 0; i < usernames.length; i += BATCH_SIZE_IN_CLAUSE) {
+      groups.push(usernames.slice(i, i + BATCH_SIZE_IN_CLAUSE));
+    }
+
+    // For each group, write a separate query
+    const promises = groups.map((group) => {
+      return dbQuery.where("github_id", "in", group).get();
+    });
+
+    const snapshots = await Promise.all(promises);
+
+    snapshots.forEach((snapshot) => {
+      snapshot.forEach((doc) => {
+        filterdUsersWithDetails.push({
+          id: doc.id,
+          ...doc.data(),
+          phone: undefined,
+          email: undefined,
+          tokens: undefined,
+          chaincode: undefined,
+        });
+      });
+    });
+
+    return {
+      filterdUsersWithDetails,
+    };
+  } catch (err) {
+    logger.error("Error retrieving user data", err);
+    throw err;
+  }
+};
+
 /**
  * Fetches the user data from the the provided username or userId
  *
@@ -292,9 +335,67 @@ const fetchUserSkills = async (id) => {
   }
 };
 
+/**
+ * Fetches user data based on the filter query
+ *
+ * @param {Object} query - Object with query parameters
+ * @param {Array} query.levelId - Array of levelIds to filter the users on
+ * @param {Array} query.levelName - Array of levelNames to filter the users on
+ * @param {Array} query.levelNumber - Array of levelNumbers to filter the users on
+ * @param {Array} query.tagId - Array of tagIds to filter the users on
+ * @param {Array} query.state - Array of states to filter the users on
+ * @return {Promise<Array>} - Array of user documents that match the filter criteria
+ */
+
+const getUsersBasedOnFilter = async (query) => {
+  const allQueryKeys = Object.keys(query);
+  const doesTagQueryExist = arraysHaveCommonItem(ITEM_TAG, allQueryKeys);
+  const doesStateQueryExist = arraysHaveCommonItem(USER_STATE, allQueryKeys);
+
+  const calls = {
+    item: itemModel,
+    state: userStatusModel,
+  };
+  calls.item = calls.item.where("itemType", "==", "USER").where("tagType", "==", "SKILL");
+
+  Object.entries(query).forEach(([key, value]) => {
+    const isTagKey = ITEM_TAG.includes(key);
+    const isStateKey = USER_STATE.includes(key);
+    const isValueArray = Array.isArray(value);
+
+    if (isTagKey) {
+      calls.item = isValueArray ? calls.item.where(key, "in", value) : calls.item.where(key, "==", value);
+    } else if (isStateKey) {
+      calls.state = isValueArray
+        ? calls.state.where("currentStatus.state", "in", value)
+        : calls.state.where("currentStatus.state", "==", value);
+    }
+  });
+
+  const tagItems = doesTagQueryExist ? (await calls.item.get()).docs.map((doc) => ({ id: doc.id, ...doc.data() })) : [];
+  const stateItems = doesStateQueryExist
+    ? (await calls.state.get()).docs.map((doc) => ({ id: doc.id, ...doc.data() }))
+    : [];
+  let finalItems = [];
+
+  if (doesTagQueryExist && doesStateQueryExist) {
+    const stateItemIds = new Set(stateItems.map((item) => item.userId));
+    finalItems = tagItems.filter((item) => stateItemIds.has(item.itemId)).map((item) => item.itemId);
+  } else if (doesStateQueryExist) {
+    finalItems = stateItems.map((item) => item.userId);
+  } else if (doesTagQueryExist) {
+    finalItems = tagItems.map((item) => item.itemId);
+  }
+
+  finalItems = [...new Set(finalItems)];
+  const userRefs = finalItems.map((itemId) => userModel.doc(itemId));
+  const userDocs = (await firestore.getAll(...userRefs)).map((doc) => ({ id: doc.id, ...doc.data() }));
+  return userDocs;
+};
+
 module.exports = {
   addOrUpdate,
-  fetchUsers,
+  fetchPaginatedUsers,
   fetchUser,
   setIncompleteUserDetails,
   initializeUser,
@@ -304,4 +405,6 @@ module.exports = {
   getJoinData,
   getSuggestedUsers,
   fetchUserSkills,
+  fetchUsers,
+  getUsersBasedOnFilter,
 };

package.json

@@ -60,13 +60,13 @@
     "sinon": "^15.0.0"
   },
   "engines": {
-    "node": "14.x"
+    "node": "18.x"
   },
   "pre-commit": [
     "lint"
   ],
   "volta": {
-    "node": "14.21.1",
+    "node": "18.15.0",
     "yarn": "1.22.19"
   }
 }

routes/users.js

@@ -15,6 +15,7 @@ router.get("/", authenticate, userValidator.getUsers, users.getUsers);
 router.get("/self", authenticate, users.getSelfDetails);
 router.get("/isUsernameAvailable/:username", authenticate, users.getUsernameAvailabilty);
 router.get("/chaincode", authenticate, users.generateChaincode);
+router.get("/search", userValidator.validateUserQueryParams, users.filterUsers);
 router.get("/:username", users.getUser);
 router.get("/:userId/intro", authenticate, authorizeRoles([SUPERUSER]), users.getUserIntro);
 router.put("/self/intro", authenticate, userValidator.validateJoinData, users.addUserIntro);