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

Author: sahsisunny

controllers/issues.js

@@ -0,0 +1,104 @@
+const issuesService = require("../services/issuesService");
+const tasks = require("../models/tasks");
+const { SOMETHING_WENT_WRONG } = require("../constants/errorMessages");
+
+/**
+ * Get the issues of the repo
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ */
+
+const getIssues = async (req, res) => {
+  try {
+    const { q: queryString } = req.query;
+    let issues = {};
+    if (queryString) {
+      const searchedIssues = await issuesService.searchOrgIssues(queryString);
+      issues.data = searchedIssues?.data?.items ?? [];
+    } else {
+      issues = await issuesService.getOrgIssues();
+    }
+
+    let issuesData = issues.data.length > 0 ? issues.data : [];
+    issuesData = issuesData.filter((issue) => !Object.keys(issue).includes("pull_request"));
+    issuesData = issuesData.map(async (issue) => {
+      const taskData = await tasks.fetchTaskByIssueId(issue.id);
+      if (taskData) {
+        issue.taskExists = true;
+      }
+
+      return issue;
+    });
+    const updatedIsuees = await Promise.all(issuesData);
+    return res.json({
+      message: "Issues returned successfully!",
+      issues: updatedIsuees,
+    });
+  } catch (err) {
+    logger.error(`Error while retriving issues ${err}`);
+    return res.boom.badImplementation(SOMETHING_WENT_WRONG);
+  }
+};
+
+/**
+ * Receive updated issue information from webhook
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ */
+const issueUpdates = async (req, res) => {
+  try {
+    const response = req.body;
+    if ("issue" in response) {
+      const { issue } = response;
+      const taskData = await tasks.fetchTaskByIssueId(issue.id);
+      if (taskData) {
+        // filtering properties with undefined or null values
+        const updatedTaskData = Object.fromEntries(Object.entries(taskData).filter(([_, value]) => value ?? false));
+
+        updatedTaskData.title = issue.title;
+        updatedTaskData.github = {
+          issue: {
+            ...updatedTaskData.github.issue,
+            status: issue.state,
+          },
+        };
+
+        // If the issue has any updates with the assignee
+        if (issue.assignee) {
+          // If there are no previous assignees or the task was not assigned before
+          if (!updatedTaskData.github.issue.assignee || !updatedTaskData.assignee) {
+            updatedTaskData.github.issue.assignee = issue.assignee.login;
+          }
+        }
+        // If the issue assignee was removed and task was not assigned
+        else if (updatedTaskData.github.issue.assignee && !updatedTaskData.assignee) {
+          delete updatedTaskData.github.issue.assignee;
+        }
+
+        if (issue.state === "closed") {
+          updatedTaskData.github.issue.closedAt = issue.closed_at;
+        }
+
+        await tasks.updateTask(updatedTaskData, taskData.id);
+        return res.json({
+          message: "Task updated successfully",
+        });
+      } else {
+        return res.json({
+          message: "No task was found for the updated issue",
+        });
+      }
+    }
+    return res.json({
+      message: "No issue was updated",
+    });
+  } catch (err) {
+    logger.error(`Error while retriving issues ${err}`);
+    return res.boom.badImplementation(SOMETHING_WENT_WRONG);
+  }
+};
+
+module.exports = {
+  getIssues,
+  issueUpdates,
+};

controllers/tasks.js

@@ -2,7 +2,7 @@ const tasks = require("../models/tasks");
 const { TASK_STATUS, TASK_STATUS_OLD } = require("../constants/tasks");
 const { addLog } = require("../models/logs");
 const { USER_STATUS } = require("../constants/users");
-const { addOrUpdate } = require("../models/users");
+const { addOrUpdate, getRdsUserInfoByGitHubUsername } = require("../models/users");
 const { OLD_ACTIVE, OLD_BLOCKED, OLD_PENDING } = TASK_STATUS_OLD;
 const { IN_PROGRESS, BLOCKED, SMOKE_TESTING, ASSIGNED } = TASK_STATUS;
 const { INTERNAL_SERVER_ERROR, SOMETHING_WENT_WRONG } = require("../constants/errorMessages");
@@ -20,6 +20,7 @@ const addNewTask = async (req, res) => {
       ...req.body,
       createdBy,
     };
+
     const task = await tasks.updateTask(body);
 
     return res.json({
@@ -41,9 +42,32 @@ const addNewTask = async (req, res) => {
 const fetchTasks = async (req, res) => {
   try {
     const allTasks = await tasks.fetchTasks();
+    const fetchTasksWithRdsAssigneeInfo = allTasks.map(async (task) => {
+      /*
+       If the issue has a "github.issue" inner object and a property "assignee",
+       then fetch the RDS user information with GitHub username in "assignee"
+      */
+      if (Object.keys(task).includes("github")) {
+        if (Object.keys(task.github.issue).includes("assignee")) {
+          return {
+            ...task,
+            github: {
+              ...task.github,
+              issue: {
+                ...task.github.issue,
+                assigneeRdsInfo: await getRdsUserInfoByGitHubUsername(task.github.issue.assignee),
+              },
+            },
+          };
+        }
+      }
+      return task;
+    });
+
+    const tasksWithRdsAssigneeInfo = await Promise.all(fetchTasksWithRdsAssigneeInfo);
     return res.json({
       message: "Tasks returned successfully!",
-      tasks: allTasks.length > 0 ? allTasks : [],
+      tasks: tasksWithRdsAssigneeInfo.length > 0 ? tasksWithRdsAssigneeInfo : [],
     });
   } catch (err) {
     logger.error(`Error while fetching tasks ${err}`);

controllers/users.js

@@ -449,12 +449,12 @@ const filterUsers = async (req, res) => {
     if (!Object.keys(req.query).length) {
       return res.boom.badRequest("filter for item not provided");
     }
-    const allUsers = await userQuery.getUsersBasedOnFilter(req.query);
+    const users = await userQuery.getUsersBasedOnFilter(req.query);
 
     return res.json({
-      message: "Users found successfully!",
-      users: allUsers,
-      count: allUsers.length,
+      message: users.length ? "Users found successfully!" : "No users found",
+      users,
+      count: users.length,
     });
   } catch (error) {
     logger.error(`Error while fetching all users: ${error}`);

middlewares/validators/tasks.js

@@ -43,6 +43,17 @@ const createTask = async (req, res, next) => {
         .optional(),
       isNoteworthy: joi.bool().optional(),
       isCollapsed: joi.bool().optional(),
+      github: joi
+        .object()
+        .keys({
+          issue: joi.object().keys({
+            status: joi.string().optional(),
+            assignee: joi.string().optional(),
+            id: joi.number().optional(),
+            closedAt: joi.string().optional(),
+          }),
+        })
+        .optional(),
     });
 
   try {

middlewares/validators/user.js

@@ -172,14 +172,17 @@ async function validateUserQueryParams(req, res, next) {
           joi.array().items(joi.string().valid("IDLE", "OOO", "ACTIVE"))
         )
         .optional(),
+    })
+    .messages({
+      "object.min": "Please provide at least one filter criteria",
     });
 
   try {
     await schema.validateAsync(req.query);
     next();
   } catch (error) {
     logger.error(`Error validating query params : ${error}`);
-    res.boom.badRequest(error.details[0].message);
+    res.boom.badRequest(error);
   }
 }
 

models/tasks.js

@@ -105,6 +105,32 @@ const fetchTask = async (taskId) => {
   }
 };
 
+/**
+ * Fetch a task against the IssueId
+ * @param issueId { number }: issueId which will be used to fetch the task
+ * @return {Promise<taskData|Object>}
+ */
+const fetchTaskByIssueId = async (issueId) => {
+  try {
+    const task = await tasksModel.where("github.issue.id", "==", issueId).get();
+    const [taskDoc] = task.docs;
+    let updatedTaskData;
+    if (taskDoc) {
+      updatedTaskData = { id: taskDoc.id, ...taskDoc.data() };
+    }
+    const taskData = await fromFirestoreData(updatedTaskData);
+
+    if (taskData?.status) {
+      taskData.status = TASK_STATUS[taskData.status.toUpperCase()];
+    }
+
+    return taskData;
+  } catch (err) {
+    logger.error("Error retrieving task data from issue Id", err);
+    throw err;
+  }
+};
+
 /**
  * Fetch assigned self task
  * @param taskId { string }: taskId which will be used to fetch the task
@@ -326,4 +352,5 @@ module.exports = {
   fetchSelfTask,
   fetchSkillLevelTask,
   overdueTasks,
+  fetchTaskByIssueId,
 };

models/users.js

@@ -59,7 +59,7 @@ const addOrUpdate = async (userData, userId = null) => {
     userData.roles = { archived: false };
     userData.incompleteUserDetails = true;
     const userInfo = await userModel.add(userData);
-    return { isNewUser: true, userId: userInfo.id };
+    return { isNewUser: true, userId: userInfo.id, incompleteUserDetails: true };
   } catch (err) {
     logger.error("Error in adding or updating user", err);
     throw err;
@@ -224,7 +224,7 @@ const fetchUsers = async (usernames = []) => {
  * @param { Object }: Object with username and userId, any of the two can be used
  * @return {Promise<{userExists: boolean, user: <userModel>}|{userExists: boolean, user: <userModel>}>}
  */
-const fetchUser = async ({ userId = null, username = null }) => {
+const fetchUser = async ({ userId = null, username = null, githubUsername = null }) => {
   try {
     let userData, id;
     if (username) {
@@ -238,6 +238,12 @@ const fetchUser = async ({ userId = null, username = null }) => {
       const user = await userModel.doc(userId).get();
       id = userId;
       userData = user.data();
+    } else if (githubUsername) {
+      const user = await userModel.where("github_id", "==", githubUsername).limit(1).get();
+      user.forEach((doc) => {
+        id = doc.id;
+        userData = doc.data();
+      });
     }
     return {
       userExists: !!userData,
@@ -335,6 +341,16 @@ const fetchUserSkills = async (id) => {
   }
 };
 
+const getRdsUserInfoByGitHubUsername = async (githubUsername) => {
+  const { user } = await fetchUser({ githubUsername });
+
+  return {
+    firstName: user.first_name ?? "",
+    lastName: user.last_name ?? "",
+    username: user.username ?? "",
+  };
+};
+
 /**
  * Fetches user data based on the filter query
  *
@@ -379,18 +395,24 @@ const getUsersBasedOnFilter = async (query) => {
   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);
+    if (stateItems.length && tagItems.length) {
+      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;
+  if (finalItems.length) {
+    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() }));
+    const filteredUserDocs = userDocs.filter((doc) => !doc.roles?.archived);
+    return filteredUserDocs;
+  }
+  return [];
 };
 
 module.exports = {
@@ -405,6 +427,7 @@ module.exports = {
   getJoinData,
   getSuggestedUsers,
   fetchUserSkills,
+  getRdsUserInfoByGitHubUsername,
   fetchUsers,
   getUsersBasedOnFilter,
 };

package.json

@@ -50,7 +50,7 @@
     "eslint-plugin-promise": "^6.0.0",
     "eslint-plugin-security": "^1.4.0",
     "eslint-plugin-standard": "^4.1.0",
-    "firebase-tools": "^11.0.0",
+    "firebase-tools": "^11.28.0",
     "mocha": "^10.0.0",
     "nock": "^13.0.11",
     "nodemon": "^2.0.7",

routes/index.js

@@ -24,5 +24,6 @@ app.use("/levels", require("./levels.js"));
 app.use("/items", require("./items.js"));
 app.use("/cache", require("./cloudflareCache.js"));
 app.use("/external-accounts", require("./external-accounts.js"));
+app.use("/issues", require("./issues.js"));
 
 module.exports = app;

routes/issues.js

@@ -0,0 +1,8 @@
+const express = require("express");
+const issues = require("../controllers/issues");
+const router = express.Router();
+
+router.get("/", issues.getIssues);
+router.post("/updates", issues.issueUpdates);
+
+module.exports = router;