feat: Add fetchTaskRequestById

Author: TanishqSingla

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,27 @@ const fetchTaskRequests = async (_, res) => {
   }
 };
 
+const fetchTaskRequestById = async (req, res) => {
+  try {
+    const id = req.params.id;
+    const data = await taskRequestsModel.fetchTaskRequestById(id);
+
+    if (data) {
+      res.status(200).json({
+        message: "Task request returned successfully",
+        data,
+      });
+    }
+
+    return res.status(404).json({
+      message: "Task request not found",
+    });
+  } 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 +102,5 @@ module.exports = {
   approveTaskRequest,
   addOrUpdate,
   fetchTaskRequests,
+  fetchTaskRequestById,
 };

models/taskRequests.js

@@ -39,6 +39,17 @@ const fetchTaskRequests = async () => {
   return taskRequests;
 };
 
+/**
+ * Fetches task request by id
+ *
+ * @param taskRequestId { string }: id of task request
+ * @return Promise<{taskRequest: Object}>
+ */
+const fetchTaskRequestById = async (taskRequestId) => {
+  const taskRequestSnapshot = await taskRequestsCollection.doc(taskRequestId).get();
+  return taskRequestSnapshot.data();
+};
+
 /**
  * Creates a task request
  *
@@ -73,11 +84,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 +129,7 @@ const approveTaskRequest = async (taskRequestId, user) => {
 
 module.exports = {
   fetchTaskRequests,
+  fetchTaskRequestById,
   addOrUpdate,
   approveTaskRequest,
 };

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

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,81 @@ 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) {
+        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 () {