Merge pull request #978 from Real-Dev-Squad/feat/filter-users-based-on-state-and-skills

Feature - Filter Users based on their state (OOO,ACTIVE,IDLE) and skills

Author: ankushdharkar

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/users.js

@@ -419,6 +419,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 +462,5 @@ module.exports = {
   getUserIntro,
   addDefaultArchivedRole,
   getUserSkills,
+  filterUsers,
 };

middlewares/validators/user.js

@@ -147,9 +147,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,13 @@ 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 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
  *
@@ -292,6 +295,64 @@ 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,
@@ -304,4 +365,5 @@ module.exports = {
   getJoinData,
   getSuggestedUsers,
   fetchUserSkills,
+  getUsersBasedOnFilter,
 };

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

utils/array.js

@@ -18,6 +18,21 @@ function chunks(array, size = 1) {
   return result;
 }
 
+/**
+ * Checks if two arrays have any common items
+ * @param array1 {Array<string, number>} - first array
+ * @param array2 {Array<string, number>} - second array
+ * @returns {boolean} - true if the arrays have at least one common item, false otherwise
+ */
+
+function arraysHaveCommonItem(array1, array2) {
+  if (!array1?.length || !array2?.length) {
+    return false;
+  }
+  return array1.some((value) => array2.includes(value));
+}
+
 module.exports = {
   chunks,
+  arraysHaveCommonItem,
 };