Modifies api to reject task requests (#1696)

* feat : adds function to reject task requests

* feat : adds tests and minor changes in validation

* chore : rename and add jsdoc for models function

* chore : update comment

* refactor: rename variables

* Update models/taskRequests.js

Co-authored-by: Yash Raj <[email protected]>

* chore: rename variable

* fix: remove stubs in integration tests

---------

Co-authored-by: Yash Raj <[email protected]>
Co-authored-by: Prakash Choudhary <[email protected]>

Author: 3 people

constants/taskRequests.ts

@@ -4,6 +4,11 @@ const TASK_REQUEST_STATUS = {
   PENDING: "PENDING",
   DENIED: "DENIED",
 };
+
+const TASK_REQUEST_ACTIONS = {
+  APPROVE: "approve",
+  REJECT: "reject",
+};
 const TASK_REQUEST_ERROR_MESSAGE = {
   INVALID_PREV: "Invalid 'prev' value",
   INVALID_NEXT: "Invalid 'next' value",
@@ -44,5 +49,6 @@ module.exports = {
   TASK_REQUEST_SORT_KEYS,
   TASK_REQUEST_ERROR_MESSAGE,
   TASK_REQUEST_SORT_VALUES,
-  MIGRATION_TYPE
-};
+  MIGRATION_TYPE,
+  TASK_REQUEST_ACTIONS,
+};

controllers/tasksRequests.js

@@ -1,5 +1,5 @@
 const { INTERNAL_SERVER_ERROR, SOMETHING_WENT_WRONG } = require("../constants/errorMessages");
-const { TASK_REQUEST_TYPE, MIGRATION_TYPE } = require("../constants/taskRequests");
+const { TASK_REQUEST_TYPE, MIGRATION_TYPE, TASK_REQUEST_ACTIONS } = require("../constants/taskRequests");
 const { addLog } = require("../models/logs");
 const taskRequestsModel = require("../models/taskRequests");
 const tasksModel = require("../models/tasks.js");
@@ -97,7 +97,7 @@ const addTaskRequests = async (req, res) => {
         break;
       }
     }
-    const newTaskRequest = await taskRequestsModel.createRequest(taskRequestData, req.userData.username);
+    const newTaskRequest = await taskRequestsModel.createRequest(taskRequestData, req.userData.id);
 
     if (newTaskRequest.isCreationRequestApproved) {
       return res.boom.conflict("Task exists for the given issue.");
@@ -111,9 +111,9 @@ const addTaskRequests = async (req, res) => {
       meta: {
         taskRequestId: newTaskRequest.id,
         action: "create",
-        createdBy: req.userData.username,
+        createdBy: req.userData.id,
         createdAt: Date.now(),
-        lastModifiedBy: req.userData.username,
+        lastModifiedBy: req.userData.id,
         lastModifiedAt: Date.now(),
       },
       body: newTaskRequest.taskRequest,
@@ -169,45 +169,62 @@ const addOrUpdate = async (req, res) => {
   }
 };
 
-const approveTaskRequest = async (req, res) => {
+const updateTaskRequests = async (req, res) => {
   try {
     const { taskRequestId, user } = req.body;
     if (!taskRequestId) {
       return res.boom.badRequest("taskRequestId not provided");
     }
 
-    const response = await taskRequestsModel.approveTaskRequest(taskRequestId, user);
+    const { action = TASK_REQUEST_ACTIONS.APPROVE } = req.query;
 
-    if (response.taskRequestNotFound) {
+    let updateTaskRequestResponse = {};
+    switch (action) {
+      case TASK_REQUEST_ACTIONS.APPROVE: {
+        updateTaskRequestResponse = await taskRequestsModel.approveTaskRequest(taskRequestId, user, req.userData.id);
+        break;
+      }
+      case TASK_REQUEST_ACTIONS.REJECT: {
+        updateTaskRequestResponse = await taskRequestsModel.rejectTaskRequest(taskRequestId, req.userData.id);
+        break;
+      }
+      default: {
+        return res.boom.badRequest("Unknown action");
+      }
+    }
+
+    if (updateTaskRequestResponse.taskRequestNotFound) {
       return res.boom.badRequest("Task request not found.");
     }
-    if (response.isUserInvalid) {
+    if (updateTaskRequestResponse.isUserInvalid) {
       return res.boom.badRequest("User request not available.");
     }
-    if (response.isTaskRequestInvalid) {
+    if (updateTaskRequestResponse.isTaskRequestInvalid) {
       return res.boom.badRequest("Task request was previously approved or rejected.");
     }
 
-    await updateUserStatusOnTaskUpdate(user.username);
+    if (action && action === TASK_REQUEST_ACTIONS.APPROVE) {
+      await updateUserStatusOnTaskUpdate(user.username);
+    }
 
     const taskRequestLog = {
       type: "taskRequests",
       meta: {
         taskRequestId: taskRequestId,
         action: "update",
-        subAction: "approve",
-        createdBy: req.userData.username,
+        subAction: action,
+        createdBy: req.userData.id,
         createdAt: Date.now(),
-        lastModifiedBy: req.userData.username,
+        lastModifiedBy: req.userData.id,
         lastModifiedAt: Date.now(),
       },
-      body: response.taskRequest,
+      body: updateTaskRequestResponse.taskRequest,
     };
     await addLog(taskRequestLog.type, taskRequestLog.meta, taskRequestLog.body);
 
     return res.status(200).json({
-      message: `Task successfully assigned to user ${response.approvedTo}`,
-      taskRequest: response.taskRequest,
+      message: `Task updated successfully.`,
+      taskRequest: updateTaskRequestResponse?.taskRequest,
     });
   } catch (err) {
     logger.error("Error while approving task request", err);
@@ -239,7 +256,7 @@ const migrateTaskRequests = async (req, res) => {
   }
 };
 module.exports = {
-  approveTaskRequest,
+  updateTaskRequests,
   addOrUpdate,
   fetchTaskRequests,
   fetchTaskRequestById,

middlewares/taskRequests.js

@@ -1,12 +1,17 @@
 const { SOMETHING_WENT_WRONG } = require("../constants/errorMessages");
 const dataAccess = require("../services/dataAccessLayer");
+const { TASK_REQUEST_ACTIONS } = require("../constants/taskRequests");
 /**
  * Validates user id for task request
  *
  * @param userId { string }: user id of the user
  */
 async function validateUser(req, res, next) {
   try {
+    const { action } = req.query;
+    if (action === TASK_REQUEST_ACTIONS.REJECT) {
+      return next();
+    }
     const { userId } = req.body;
 
     if (!userId) {

models/taskRequests.js

@@ -187,7 +187,28 @@ const fetchTaskRequestById = async (taskRequestId) => {
   };
 };
 
-const createRequest = async (data, authenticatedUsername) => {
+/**
+ * Creates a task request with user details.
+ *
+ * @param {Object} data - The data for creating the task request.
+ * @param {string} data.userId - The ID of the user to whom the task request is being created.
+ * @param {string} data.proposedDeadline - The proposed deadline for the task.
+ * @param {string} data.proposedStartDate - The proposed start date for the task.
+ * @param {string} data.description - The description of the task request.
+ * @param {string} data.taskTitle - The title of the task.
+ * @param {string} data.taskId - The ID of the task (optional).
+ * @param {string} data.externalIssueUrl - The external issue URL (optional).
+ * @param {string} data.requestType - The type of the task request (CREATION | ASSIGNMENT).
+ * @param {string} authorUserId - The ID of the authenticated user creating the request.
+ * @returns {Promise<{
+ *   isCreationRequestApproved: boolean | undefined,
+ *   alreadyRequesting: boolean | undefined,
+ *   id: string,
+ *   isCreate: boolean,
+ *   taskRequest: Object,
+ * }>}
+ */
+const createRequest = async (data, authorUserId) => {
   try {
     const queryFieldPath = data.requestType === TASK_REQUEST_TYPE.CREATION ? "externalIssueUrl" : "taskId";
     const queryValue = data.requestType === TASK_REQUEST_TYPE.CREATION ? data.externalIssueUrl : data.taskId;
@@ -233,7 +254,7 @@ const createRequest = async (data, authenticatedUsername) => {
       const updatedTaskRequest = {
         requestors: updatedRequestors,
         users: updatedUsers,
-        lastModifiedBy: authenticatedUsername,
+        lastModifiedBy: authorUserId,
         lastModifiedAt: Date.now(),
       };
       await taskRequestsCollection.doc(taskRequestRef.id).update(updatedTaskRequest);
@@ -254,9 +275,9 @@ const createRequest = async (data, authenticatedUsername) => {
       externalIssueUrl: data.externalIssueUrl,
       requestType: data.requestType,
       users: [userRequest],
-      createdBy: authenticatedUsername,
+      createdBy: authorUserId,
       createdAt: Date.now(),
-      lastModifiedBy: authenticatedUsername,
+      lastModifiedBy: authorUserId,
       lastModifiedAt: Date.now(),
     };
     if (!newTaskRequest.externalIssueUrl) delete newTaskRequest.externalIssueUrl;
@@ -321,13 +342,20 @@ const addOrUpdate = async (taskId, userId) => {
 };
 
 /**
- * Approves task request to user
+ * Approve task request for a user.
  *
- * @param taskRequestId { string }: id of task request
- * @param userId { Object }: user whose being approved
- * @return {Promise<{approvedTo: string, taskRequest: Object}>}
+ * @param {string} taskRequestId - The ID of the task request.
+ * @param {Object} user - The user to whom the task request is being approved.
+ * @param {string} authorUserId - The ID of the authenticated user performing the approval.
+ * @returns {Promise<{
+ *   approvedTo: string,
+ *   taskRequest: Object,
+ *   taskRequestNotFound: boolean | undefined
+ *   isUserInvalid: boolean | undefined
+ *   isTaskRequestInvalid: boolean | undefined
+ * }>}
  */
-const approveTaskRequest = async (taskRequestId, user) => {
+const approveTaskRequest = async (taskRequestId, user, authorUserId) => {
   try {
     return await firestore.runTransaction(async (transaction) => {
       const taskRequestDocRef = taskRequestsCollection.doc(taskRequestId);
@@ -364,6 +392,8 @@ const approveTaskRequest = async (taskRequestId, user) => {
           users: taskRequestData.users,
           approvedTo: user.id,
           status: TASK_REQUEST_STATUS.APPROVED,
+          lastModifiedBy: authorUserId,
+          lastModifiedAt: Date.now(),
         };
         // End of TODO
         const updateTaskRequestPromise = transaction.update(taskRequestDocRef, updatedTaskRequest);
@@ -397,6 +427,8 @@ const approveTaskRequest = async (taskRequestId, user) => {
         const updatedTaskRequest = {
           approvedTo: user.id,
           status: TASK_REQUEST_STATUS.APPROVED,
+          lastModifiedBy: authorUserId,
+          lastModifiedAt: Date.now(),
         };
         let userRequestData;
         if (taskRequestData.users) {
@@ -435,6 +467,38 @@ const approveTaskRequest = async (taskRequestId, user) => {
   }
 };
 
+/**
+ * Rejects a task request.
+ *
+ * @param {string} taskRequestId - The ID of the task request.
+ * @param {string} authorUserId - The ID of the authenticated or logged in user performing the rejection.
+ * @returns {Promise<{taskRequest: Object
+ *   taskRequestNotFound: boolean | undefined
+ *   isTaskRequestInvalid: boolean | undefined
+ * }>}
+ */
+const rejectTaskRequest = async (taskRequestId, authorUserId) => {
+  const taskRequestDoc = taskRequestsCollection.doc(taskRequestId);
+  const taskRequestData = (await taskRequestDoc.get()).data();
+  if (!taskRequestData) {
+    return { taskRequestNotFound: true };
+  }
+
+  if (
+    taskRequestData.status === TASK_REQUEST_STATUS.APPROVED ||
+    taskRequestData.status === TASK_REQUEST_STATUS.DENIED
+  ) {
+    return { isTaskRequestInvalid: true };
+  }
+  const updatedTaskRequest = {
+    status: TASK_REQUEST_STATUS.DENIED,
+    lastModifiedBy: authorUserId,
+    lastModifiedAt: Date.now(),
+  };
+  await taskRequestDoc.update(updatedTaskRequest);
+  return { taskRequest: { ...taskRequestData, ...updatedTaskRequest } };
+};
+
 const addNewFields = async () => {
   const taskRequestsSnapshots = (await taskRequestsCollection.get()).docs;
 
@@ -506,4 +570,5 @@ module.exports = {
   fetchPaginatedTaskRequests,
   addNewFields,
   removeOldField,
+  rejectTaskRequest,
 };

routes/taskRequests.js

@@ -10,7 +10,8 @@ const validators = require("../middlewares/validators/task-requests");
 router.get("/", authenticate, taskRequests.fetchTaskRequests);
 router.get("/:id", authenticate, taskRequests.fetchTaskRequestById);
 router.post("/addOrUpdate", authenticate, validateUser, taskRequests.addOrUpdate);
-router.patch("/approve", authenticate, authorizeRoles([SUPERUSER]), validateUser, taskRequests.approveTaskRequest);
+router.patch("/approve", authenticate, authorizeRoles([SUPERUSER]), validateUser, taskRequests.updateTaskRequests);
+router.patch("/", authenticate, authorizeRoles([SUPERUSER]), validateUser, taskRequests.updateTaskRequests);
 router.post("/", authenticate, validators.postTaskRequests, taskRequests.addTaskRequests);
 router.post("/migrations", authenticate, authorizeRoles([SUPERUSER]), taskRequests.migrateTaskRequests);