Merge pull request #1276 from Real-Dev-Squad/1273-fetch-route-for-task-request-using-query-params

iamitprakash · web-flow · commit a3131fc71c0d · 2023-08-06T03:27:03.000+05:30
feat: Add fetchTaskRequestById
diff --git a/controllers/tasksRequests.js b/controllers/tasksRequests.js
@@ -6,8 +6,8 @@ const fetchTaskRequests = async (_, res) => {
   try {
     const data = await taskRequestsModel.fetchTaskRequests();
 
-    if (data || data.length > 0) {
-      res.status(200).json({
+    if (data.length > 0) {
+      return res.status(200).json({
         message: "Task requests returned successfully",
         data,
       });
@@ -23,6 +23,26 @@ const fetchTaskRequests = async (_, res) => {
   }
 };
 
+const fetchTaskRequestById = async (req, res) => {
+  try {
+    const id = req.params.id;
+    const data = await taskRequestsModel.fetchTaskRequestById(id);
+
+    if (!data.taskRequestExists) {
+      return res.status(404).json({
+        message: "Task request not found",
+      });
+    }
+    return res.status(200).json({
+      message: "Task request returned successfully",
+      data: data.taskRequestData,
+    });
+  } catch (err) {
+    logger.error("Error while fetching task requests", err);
+    return res.boom.badImplementation(INTERNAL_SERVER_ERROR);
+  }
+};
+
 const addOrUpdate = async (req, res) => {
   try {
     const { taskId, userId } = req.body;
@@ -81,4 +101,5 @@ module.exports = {
   approveTaskRequest,
   addOrUpdate,
   fetchTaskRequests,
+  fetchTaskRequestById,
 };
diff --git a/models/taskRequests.js b/models/taskRequests.js
@@ -13,32 +13,66 @@ const userModel = require("./users");
 const fetchTaskRequests = async () => {
   const taskRequests = [];
 
-  const taskRequestsSnapshots = (await taskRequestsCollection.get()).docs;
+  try {
+    const taskRequestsSnapshots = (await taskRequestsCollection.get()).docs;
 
-  const taskPromises = [];
-  const userPromises = [];
+    const taskPromises = [];
+    const userPromises = [];
 
-  taskRequestsSnapshots.forEach((taskRequestsSnapshot) => {
-    const taskRequestData = taskRequestsSnapshot.data();
-    const { requestors } = taskRequestData;
+    taskRequestsSnapshots.forEach((taskRequestsSnapshot) => {
+      const taskRequestData = taskRequestsSnapshot.data();
+      taskRequestData.id = taskRequestsSnapshot.id;
+      taskRequestData.url = new URL(`/taskRequests/${taskRequestData.id}`, config.get("services.rdsUi.baseUrl"));
+      const { requestors } = taskRequestData;
 
-    taskPromises.push(tasksModel.fetchTask(taskRequestData.taskId));
-    userPromises.push(Promise.all(requestors.map((requestor) => userModel.fetchUser({ userId: requestor }))));
+      taskPromises.push(tasksModel.fetchTask(taskRequestData.taskId));
+      userPromises.push(Promise.all(requestors.map((requestor) => userModel.fetchUser({ userId: requestor }))));
 
-    taskRequests.push(taskRequestData);
-  });
+      taskRequests.push(taskRequestData);
+    });
 
-  const tasks = await Promise.all(taskPromises);
-  const users = await Promise.all(userPromises);
+    const tasks = await Promise.all(taskPromises);
+    const users = await Promise.all(userPromises);
 
-  taskRequests.forEach((taskRequest, index) => {
-    taskRequest.task = tasks[+index].taskData;
-    taskRequest.requestors = users[+index];
-  });
+    taskRequests.forEach((taskRequest, index) => {
+      taskRequest.task = tasks[+index].taskData;
+      taskRequest.requestors = users[+index];
+    });
+  } catch (err) {
+    logger.error("Error in updating task", err);
+  }
 
   return taskRequests;
 };
 
+/**
+ * Fetches task request by id
+ *
+ * @param taskRequestId { string }: id of task request
+ * @return Promise<{taskRequest: Object}>
+ */
+const fetchTaskRequestById = async (taskRequestId) => {
+  try {
+    const taskRequestSnapshot = await taskRequestsCollection.doc(taskRequestId).get();
+    const taskRequestData = taskRequestSnapshot.data();
+
+    if (taskRequestData) {
+      taskRequestData.id = taskRequestSnapshot.id;
+      taskRequestData.url = new URL(`/taskRequests/${taskRequestData.id}`, config.get("services.rdsUi.baseUrl"));
+    }
+    return {
+      taskRequestData,
+      taskRequestExists: true,
+    };
+  } catch (err) {
+    logger.error("Error in updating task", err);
+  }
+
+  return {
+    taskRequestExists: false,
+  };
+};
+
 /**
  * Creates a task request
  *
@@ -73,11 +107,12 @@ const addOrUpdate = async (taskId, userId) => {
       taskId,
     };
 
-    await taskRequestsCollection.add(newTaskRequest);
+    const newTaskRequestRef = await taskRequestsCollection.add(newTaskRequest);
 
     return {
       isCreate: true,
       taskRequest: newTaskRequest,
+      id: newTaskRequestRef.id,
     };
   } catch (err) {
     logger.error("Error in updating task", err);
@@ -117,6 +152,7 @@ const approveTaskRequest = async (taskRequestId, user) => {
 
 module.exports = {
   fetchTaskRequests,
+  fetchTaskRequestById,
   addOrUpdate,
   approveTaskRequest,
 };
diff --git a/routes/taskRequests.js b/routes/taskRequests.js
@@ -8,6 +8,7 @@ const { cacheResponse } = require("../utils/cache");
 const { validateUser } = require("../middlewares/taskRequests");
 
 router.get("/", authenticate, authorizeRoles([SUPERUSER]), cacheResponse(), taskRequests.fetchTaskRequests);
+router.get("/:id", authenticate, authorizeRoles([SUPERUSER]), taskRequests.fetchTaskRequestById);
 router.post("/addOrUpdate", authenticate, validateUser, taskRequests.addOrUpdate);
 router.patch("/approve", authenticate, authorizeRoles([SUPERUSER]), validateUser, taskRequests.approveTaskRequest);
 
diff --git a/test/integration/taskRequests.test.js b/test/integration/taskRequests.test.js
@@ -58,10 +58,9 @@ describe("Task Requests", function () {
 
         taskId = (await tasksModel.updateTask(taskData[4])).taskId;
         await userStatusModel.updateUserStatus(userId, idleUserStatus);
-        await taskRequestsModel.addOrUpdate(taskId, userId);
       });
 
-      it("should fetch taskRequests", function (done) {
+      it("should fetch 404 when taskRequests are empty", function (done) {
         chai
           .request(app)
           .get("/taskRequests")
@@ -71,13 +70,30 @@ describe("Task Requests", function () {
               return done(err);
             }
 
+            expect(res).to.have.status(404);
+            return done();
+          });
+      });
+
+      it("should fetch taskRequests", async function () {
+        await taskRequestsModel.addOrUpdate(taskId, userId);
+
+        chai
+          .request(app)
+          .get("/taskRequests")
+          .set("cookie", `${cookieName}=${jwt}`)
+          .then(function (err, res) {
+            if (err) {
+              return err;
+            }
+
             expect(res).to.have.status(200);
             expect(res.body.message).to.equal("Task requests returned successfully");
             expect(res.body.data).to.be.a("Array");
             expect(res.body.data.length).to.equal(1);
             expect(res.body.data[0]).to.have.property("requestors");
             expect(res.body.data[0].requestors.length).to.equal(1);
-            return done();
+            return res;
           });
       });
     });
@@ -111,6 +127,83 @@ describe("Task Requests", function () {
     });
   });
 
+  describe("GET /taskRequest/:id - fetches task request by id", function () {
+    describe("When the user is super user", function () {
+      let taskRequestId;
+      before(async function () {
+        superUserId = await addUser(superUser);
+        sinon.stub(authService, "verifyAuthToken").callsFake(() => ({ userId: superUserId }));
+        jwt = authService.generateAuthToken({ userId: superUserId });
+
+        taskId = (await tasksModel.updateTask(taskData[4])).taskId;
+        taskRequestId = (await taskRequestsModel.addOrUpdate(taskId, userId)).id;
+      });
+
+      it("should fetch the task request", function (done) {
+        chai
+          .request(app)
+          .get(`/taskRequests/${taskRequestId}`)
+          .set("cookie", `${cookieName}=${jwt}`)
+          .end((err, res) => {
+            if (err) {
+              return done(err);
+            }
+
+            expect(res).to.have.status(200);
+            expect(res.body.message).to.be.equal("Task request returned successfully");
+            expect(res.body.data).to.be.a("object");
+            return done();
+          });
+      });
+
+      it("should return 404 if the resource is not found", function (done) {
+        sinon.stub(taskRequestsModel, "fetchTaskRequestById").callsFake(() => []);
+
+        chai
+          .request(app)
+          .get(`/taskRequests/taskRequestId`)
+          .set("cookie", `${cookieName}=${jwt}`)
+          .end((err, res) => {
+            if (err) {
+              return done(err);
+            }
+
+            expect(res).to.have.status(404);
+            expect(res.body.message).to.be.equal("Task request not found");
+            return done();
+          });
+      });
+    });
+
+    describe("When the user is not a super user", function () {
+      before(async function () {
+        userId = await addUser(member);
+        sinon.stub(authService, "verifyAuthToken").callsFake(() => ({ userId }));
+        jwt = authService.generateAuthToken({ userId });
+
+        taskId = (await tasksModel.updateTask(taskData[4])).taskId;
+
+        await userStatusModel.updateUserStatus(userId, idleUserStatus);
+        await taskRequestsModel.addOrUpdate(taskId, userId);
+      });
+
+      it("should return 401 status code", function (done) {
+        chai
+          .request(app)
+          .get(`/taskRequests/taskrequstid`)
+          .set("cookie", `${cookieName}=${jwt}`)
+          .end((err, res) => {
+            if (err) {
+              return done(err);
+            }
+
+            expect(res).to.have.status(401);
+            return done();
+          });
+      });
+    });
+  });
+
   describe("POST /taskRequests/addOrUpdate - add or updates a task request", function () {
     describe("When a new task requested is created", function () {
       before(async function () {
