dev to main sync (#1618)

Author: shubhamsinghbundela

constants/taskRequests.js

@@ -1,6 +1,13 @@
 const TASK_REQUEST_STATUS = {
   WAITING: "WAITING",
   APPROVED: "APPROVED",
+  PENDING: "PENDING",
+  DENIED: "DENIED",
 };
 
-module.exports = { TASK_REQUEST_STATUS };
+const TASK_REQUEST_TYPE = {
+  ASSIGNMENT: "ASSIGNMENT",
+  CREATION: "CREATION",
+};
+
+module.exports = { TASK_REQUEST_STATUS, TASK_REQUEST_TYPE };

constants/tasks.js

@@ -30,6 +30,7 @@ const TASK_STATUS_OLD = {
   OLD_PENDING: "pending",
   OLD_COMPLETED: "completed",
 };
+const DEFAULT_TASK_PRIORITY = "TBD";
 
 const MAPPED_TASK_STATUS = {
   ...TASK_STATUS,
@@ -39,4 +40,4 @@ const MAPPED_TASK_STATUS = {
 
 const TASK_SIZE = 5;
 
-module.exports = { TASK_TYPE, TASK_STATUS, TASK_STATUS_OLD, MAPPED_TASK_STATUS, TASK_SIZE };
+module.exports = { TASK_TYPE, TASK_STATUS, TASK_STATUS_OLD, MAPPED_TASK_STATUS, TASK_SIZE, DEFAULT_TASK_PRIORITY };

controllers/extensionRequests.js

@@ -6,6 +6,8 @@ const { EXTENSION_REQUEST_STATUS } = require("../constants/extensionRequests");
 const { INTERNAL_SERVER_ERROR } = require("../constants/errorMessages");
 const { transformQuery } = require("../utils/extensionRequests");
 const { parseQueryParams } = require("../utils/queryParser");
+const logsQuery = require("../models/logs");
+const { getFullName } = require("../utils/users");
 
 /**
  * Create ETA extension Request
@@ -232,6 +234,23 @@ const getSelfExtensionRequests = async (req, res) => {
           if (latestExtensionRequest && latestExtensionRequest.assigneeId !== userId) {
             allExtensionRequests = [];
           } else {
+            // Add reviewer's name if status is not PENDING
+            if (latestExtensionRequest.status === "APPROVED" || latestExtensionRequest.status === "DENIED") {
+              const logs = await logsQuery.fetchLogs(
+                { "meta.extensionRequestId": latestExtensionRequest.id, limit: 1 },
+                "extensionRequests"
+              );
+
+              if (
+                logs.length === 1 &&
+                logs[0]?.meta?.userId &&
+                (logs[0]?.body?.status === "APPROVED" || logs[0]?.body?.status === "DENIED") // Make sure log is only related to status change
+              ) {
+                const superUserId = logs[0].meta.userId;
+                const name = await getFullName(superUserId);
+                latestExtensionRequest.reviewedBy = `${name?.first_name} ${name?.last_name}`;
+              }
+            }
             allExtensionRequests = [latestExtensionRequest];
           }
         } else {
@@ -270,6 +289,7 @@ const getSelfExtensionRequests = async (req, res) => {
  */
 const updateExtensionRequest = async (req, res) => {
   try {
+    const { dev = "false" } = req.query;
     const extensionRequest = await extensionRequestsQuery.fetchExtensionRequest(req.params.id);
     if (!extensionRequest.extensionRequestData) {
       return res.boom.notFound("Extension Request not found");
@@ -282,7 +302,39 @@ const updateExtensionRequest = async (req, res) => {
       }
     }
 
-    await extensionRequestsQuery.updateExtensionRequest(req.body, req.params.id);
+    const promises = [extensionRequestsQuery.updateExtensionRequest(req.body, req.params.id)];
+    // If flag is present, then only create log for change in ETA/reason by SU
+    if (dev === "true") {
+      let body = {};
+      // Check if reason has been changed
+      if (req.body.reason && req.body.reason !== extensionRequest.extensionRequestData.reason) {
+        body = { ...body, oldReason: extensionRequest.extensionRequestData.reason, newReason: req.body.reason };
+      }
+      // Check if newEndsOn has been changed
+      if (req.body.newEndsOn && req.body.newEndsOn !== extensionRequest.extensionRequestData.newEndsOn) {
+        body = { ...body, oldEndsOn: extensionRequest.extensionRequestData.newEndsOn, newEndsOn: req.body.newEndsOn };
+      }
+      // Check if title has been changed
+      if (req.body.title && req.body.title !== extensionRequest.extensionRequestData.title) {
+        body = { ...body, oldTitle: extensionRequest.extensionRequestData.title, newTitle: req.body.title };
+      }
+
+      // Validate if there's any update that actually happened, then only create the log
+      if (Object.keys(body).length > 0) {
+        const extensionLog = {
+          type: "extensionRequests",
+          meta: {
+            extensionRequestId: req.params.id,
+            taskId: extensionRequest.extensionRequestData.taskId,
+            userId: req.userData.id,
+          },
+          body,
+        };
+        promises.push(addLog(extensionLog.type, extensionLog.meta, extensionLog.body));
+      }
+    }
+    await Promise.all(promises);
+
     return res.status(204).send();
   } catch (err) {
     logger.error(`Error while updating extension request: ${err}`);
@@ -298,6 +350,7 @@ const updateExtensionRequest = async (req, res) => {
  */
 const updateExtensionRequestStatus = async (req, res) => {
   try {
+    const { dev = "false" } = req.query;
     const extensionRequest = await extensionRequestsQuery.fetchExtensionRequest(req.params.id);
     if (!extensionRequest.extensionRequestData) {
       return res.boom.notFound("Extension Request not found");
@@ -307,6 +360,7 @@ const updateExtensionRequestStatus = async (req, res) => {
     const extensionLog = {
       type: "extensionRequests",
       meta: {
+        ...(dev === "true" && { extensionRequestId: req.params.id }), // if flag is present, add extensionRequestId
         taskId: extensionRequest.extensionRequestData.taskId,
         username: req.userData.username,
         userId: req.userData.id,

controllers/tasksRequests.js

@@ -1,10 +1,14 @@
 const { INTERNAL_SERVER_ERROR, SOMETHING_WENT_WRONG } = require("../constants/errorMessages");
+const { TASK_REQUEST_TYPE } = require("../constants/taskRequests");
 const taskRequestsModel = require("../models/taskRequests");
 const tasksModel = require("../models/tasks.js");
+const githubService = require("../services/githubService");
+const usersUtils = require("../utils/users");
 
 const fetchTaskRequests = async (_, res) => {
   try {
-    const data = await taskRequestsModel.fetchTaskRequests();
+    const { dev } = _.query;
+    const data = await taskRequestsModel.fetchTaskRequests(dev === "true");
 
     if (data.length > 0) {
       return res.status(200).json({
@@ -43,6 +47,73 @@ const fetchTaskRequestById = async (req, res) => {
   }
 };
 
+const addTaskRequests = async (req, res) => {
+  try {
+    const taskRequestData = req.body;
+    const usernamePromise = usersUtils.getUsername(taskRequestData.userId);
+    if (req.userData.id !== taskRequestData.userId && !req.userData.roles?.super_user) {
+      return res.boom.forbidden("Not authorized to create the request");
+    }
+    if (taskRequestData.proposedDeadline < taskRequestData.proposedStartDate) {
+      return res.boom.badRequest("Task deadline cannot be before the start date");
+    }
+    switch (taskRequestData.requestType) {
+      case TASK_REQUEST_TYPE.ASSIGNMENT: {
+        const taskDataPromise = tasksModel.fetchTask(taskRequestData.taskId);
+
+        const [{ taskData }, username] = await Promise.all([taskDataPromise, usernamePromise]);
+        taskRequestData.taskTitle = taskData?.title;
+        if (!username) {
+          return res.boom.badRequest("User not found");
+        }
+        if (!taskData) {
+          return res.boom.badRequest("Task does not exist");
+        }
+        break;
+      }
+      case TASK_REQUEST_TYPE.CREATION: {
+        let issuePromise;
+        try {
+          const url = new URL(taskRequestData.externalIssueUrl);
+          const issueUrlPaths = url.pathname.split("/");
+          const repositoryName = issueUrlPaths[3];
+          const issueNumber = issueUrlPaths[5];
+          issuePromise = githubService.fetchIssuesById(repositoryName, issueNumber);
+        } catch (error) {
+          return res.boom.badRequest("External issue url is not valid");
+        }
+        const [issueData, username] = await Promise.all([issuePromise, usernamePromise]);
+        taskRequestData.taskTitle = issueData?.title;
+        if (!username) {
+          return res.boom.badRequest("User not found");
+        }
+        if (!issueData) {
+          return res.boom.badRequest("Issue does not exist");
+        }
+        break;
+      }
+    }
+    const newTaskRequest = await taskRequestsModel.createRequest(taskRequestData, req.userData.username);
+    if (newTaskRequest.isCreationRequestApproved) {
+      return res.boom.conflict("Task exists for the given issue.");
+    }
+    if (newTaskRequest.alreadyRequesting) {
+      return res.boom.badRequest("Task was already requested");
+    }
+    const statusCode = newTaskRequest.isCreate ? 201 : 200;
+    return res.status(statusCode).json({
+      message: "Task request successful.",
+      data: {
+        id: newTaskRequest.id,
+        ...newTaskRequest.taskRequest,
+      },
+    });
+  } catch (err) {
+    logger.error("Error while creating task request");
+    return res.boom.serverUnavailable(SOMETHING_WENT_WRONG);
+  }
+};
+
 const addOrUpdate = async (req, res) => {
   try {
     const { taskId, userId } = req.body;
@@ -87,6 +158,15 @@ const approveTaskRequest = async (req, res) => {
 
     const response = await taskRequestsModel.approveTaskRequest(taskRequestId, user);
 
+    if (response.taskRequestNotFound) {
+      return res.boom.badRequest("Task request not found.");
+    }
+    if (response.isUserInvalid) {
+      return res.boom.badRequest("User request not available.");
+    }
+    if (response.isTaskRequestInvalid) {
+      return res.boom.badRequest("Task request was previously approved or rejected.");
+    }
     return res.status(200).json({
       message: `Task successfully assigned to user ${response.approvedTo}`,
       taskRequest: response.taskRequest,
@@ -102,4 +182,5 @@ module.exports = {
   addOrUpdate,
   fetchTaskRequests,
   fetchTaskRequestById,
+  addTaskRequests,
 };

controllers/users.js

@@ -80,11 +80,17 @@ const getUserById = async (req, res) => {
 const getUsers = async (req, res) => {
   try {
     // getting user details by id if present.
-    const query = req.query?.query ?? "";
-    const transformedQuery = parseSearchQuery(query);
-    const qualifiers = getQualifiers(query);
-
+    const { q, dev: devParam, query } = req.query;
+    const dev = devParam === "true";
+    const queryString = (dev ? q : query) || "";
+    const transformedQuery = parseSearchQuery(queryString);
+    const qualifiers = getQualifiers(queryString);
+    // Should throw an error if the new query parameter is without feature flag
+    if (q && !dev) {
+      return res.boom.notFound("Route not found");
+    }
     // getting user details by id if present.
+
     if (req.query.id) {
       const id = req.query.id;
       let result, user;
@@ -135,7 +141,6 @@ const getUsers = async (req, res) => {
     // getting user details by discord id if present.
     const discordId = req.query.discordId;
 
-    const dev = req.query.dev === "true";
     if (req.query.discordId) {
       if (dev) {
         let result, user;

middlewares/taskRequests.js

@@ -24,9 +24,6 @@ async function validateUser(req, res, next) {
     if (!userStatusExists) {
       return res.boom.conflict("User status does not exist");
     }
-    if (userStatus.currentStatus.state === userState.OOO) {
-      return res.boom.conflict("User is currently OOO");
-    }
     if (userStatus.currentStatus.state === userState.ACTIVE) {
       return res.boom.conflict("User is currently active on another task");
     }

middlewares/validators/task-requests.js

@@ -0,0 +1,45 @@
+const joi = require("joi");
+const { TASK_REQUEST_TYPE } = require("../../constants/taskRequests");
+const githubOrg = config.get("githubApi.org");
+const githubBaseUrl = config.get("githubApi.baseUrl");
+const githubIssuerUrlPattern = new RegExp(`^${githubBaseUrl}/repos/${githubOrg}/.+/issues/\\d+$`);
+
+const postTaskRequests = async (req, res, next) => {
+  const taskAssignmentSchema = joi
+    .object()
+    .strict()
+    .keys({
+      taskId: joi.string().required(),
+      externalIssueUrl: joi.string().regex(githubIssuerUrlPattern).optional(),
+      requestType: joi.string().valid(TASK_REQUEST_TYPE.ASSIGNMENT).required(),
+      userId: joi.string().required(),
+      proposedStartDate: joi.number().required(),
+      proposedDeadline: joi.number().required(),
+      description: joi.string().optional(),
+    });
+
+  const taskCreationSchema = joi
+    .object()
+    .strict()
+    .keys({
+      externalIssueUrl: joi.string().regex(githubIssuerUrlPattern).required(),
+      requestType: joi.string().valid(TASK_REQUEST_TYPE.CREATION).required(),
+      userId: joi.string().required(),
+      proposedStartDate: joi.number().required(),
+      proposedDeadline: joi.number().required(),
+      description: joi.string().optional(),
+    });
+  const schema = joi.alternatives().try(taskAssignmentSchema, taskCreationSchema);
+
+  try {
+    await schema.validateAsync(req.body);
+    next();
+  } catch (error) {
+    logger.error(`Error validating postTaskRequests payload : ${error}`);
+    res.boom.badRequest(error.details[0].context.message);
+  }
+};
+
+module.exports = {
+  postTaskRequests,
+};

middlewares/validators/user.js

@@ -189,6 +189,7 @@ async function getUsers(req, res, next) {
           "string.empty": "prev value cannot be empty",
         }),
       query: joi.string().optional(),
+      q: joi.string().optional(),
       filterBy: joi.string().optional(),
       days: joi.string().optional(),
       dev: joi.string().optional(),

models/logs.js

@@ -4,6 +4,7 @@ const logsModel = firestore.collection("logs");
 const admin = require("firebase-admin");
 const { logType } = require("../constants/logs");
 const { INTERNAL_SERVER_ERROR } = require("../constants/errorMessages");
+const { getFullName } = require("../utils/users");
 
 /**
  * Adds log
@@ -35,15 +36,17 @@ const addLog = async (type, meta, body) => {
  */
 const fetchLogs = async (query, param) => {
   try {
+    const { dev, ...remainingQuery } = query;
     let call = logsModel.where("type", "==", param);
-    Object.keys(query).forEach((key) => {
+    Object.keys(remainingQuery).forEach((key) => {
       // eslint-disable-next-line security/detect-object-injection
       if (key !== "limit" && key !== "lastDocId") {
-        call = call.where(key, "==", query[key]);
+        // eslint-disable-next-line security/detect-object-injection
+        call = call.where(key, "==", remainingQuery[key]);
       }
     });
 
-    const { limit, lastDocId, userId } = query;
+    const { limit, lastDocId, userId } = remainingQuery;
     let lastDoc;
     const limitDocuments = Number(limit);
 
@@ -75,6 +78,22 @@ const fetchLogs = async (query, param) => {
         ...doc.data(),
       });
     });
+
+    // If dev flag is presend and extensionRequest logs are requested, populate userId
+    if (dev === "true" && param === "extensionRequests") {
+      const userIdNameMap = {};
+      for await (const log of logs) {
+        if (log.meta.userId) {
+          if (userIdNameMap[log.meta.userId]) {
+            log.meta.name = userIdNameMap[log.meta.userId];
+          } else {
+            const name = await getFullName(log.meta.userId);
+            log.meta.name = `${name?.first_name} ${name?.last_name}`;
+            userIdNameMap[log.meta.userId] = log.meta.name;
+          }
+        }
+      }
+    }
     return logs;
   } catch (err) {
     logger.error("Error in adding log", err);