Merge pull request #1327 from Real-Dev-Squad/feature/search-task

Add filter by query for task

Author: iamitprakash

controllers/tasks.js

@@ -11,6 +11,7 @@ const { transformQuery } = require("../utils/tasks");
 const { getPaginatedLink } = require("../utils/helper");
 const { updateUserStatusOnTaskUpdate, updateStatusOnTaskCompletion } = require("../models/userStatus");
 const dataAccess = require("../services/dataAccessLayer");
+const { parseSearchQuery } = require("../utils/tasks");
 /**
  * Creates new task
  *
@@ -128,7 +129,7 @@ const fetchPaginatedTasks = async (query) => {
 
 const fetchTasks = async (req, res) => {
   try {
-    const { dev, status, page, size, prev, next } = req.query;
+    const { dev, status, page, size, prev, next, q: queryString } = req.query;
     const transformedQuery = transformQuery(dev, status, size, page);
 
     if (dev) {
@@ -139,12 +140,33 @@ const fetchTasks = async (req, res) => {
       });
     }
 
+    if (queryString !== undefined) {
+      const searchParams = parseSearchQuery(queryString);
+      const filterTasks = await tasks.fetchTasks(searchParams.searchTerm);
+      const tasksWithRdsAssigneeInfo = await fetchTasksWithRdsAssigneeInfo(filterTasks);
+      if (tasksWithRdsAssigneeInfo.length === 0) {
+        return res.status(404).json({
+          message: "No tasks found.",
+          tasks: [],
+        });
+      }
+      return res.json({
+        message: "Filter tasks returned successfully!",
+        tasks: tasksWithRdsAssigneeInfo,
+      });
+    }
+
     const allTasks = await tasks.fetchTasks();
     const tasksWithRdsAssigneeInfo = await fetchTasksWithRdsAssigneeInfo(allTasks);
-
+    if (tasksWithRdsAssigneeInfo.length === 0) {
+      return res.status(404).json({
+        message: "No tasks found",
+        tasks: [],
+      });
+    }
     return res.json({
       message: "Tasks returned successfully!",
-      tasks: tasksWithRdsAssigneeInfo.length > 0 ? tasksWithRdsAssigneeInfo : [],
+      tasks: tasksWithRdsAssigneeInfo,
     });
   } catch (err) {
     logger.error(`Error while fetching tasks ${err}`);

middlewares/validators/tasks.js

@@ -164,6 +164,19 @@ const getTasksValidator = async (req, res, next) => {
         })
       ),
     size: joi.number().integer().positive().min(1).max(100).optional(),
+    q: joi
+      .string()
+      .optional()
+      .custom((value, helpers) => {
+        if (value && value.includes(":")) {
+          const [key] = value.split(":");
+          const allowedKeywords = ["searchterm"];
+          if (!allowedKeywords.includes(key.toLowerCase())) {
+            return helpers.error("any.invalid");
+          }
+        }
+        return value;
+      }, "Invalid query format"),
   });
 
   try {

models/tasks.js

@@ -96,10 +96,14 @@ const addDependency = async (data) => {
  * @return {Promise<tasks|Array>}
  */
 
-const getBuiltTasks = async (tasksSnapshot) => {
+const getBuiltTasks = async (tasksSnapshot, searchTerm) => {
   const tasks = buildTasks(tasksSnapshot);
   const promises = tasks.map(async (task) => fromFirestoreData(task));
-  const updatedTasks = await Promise.all(promises);
+  let updatedTasks = await Promise.all(promises);
+
+  if (searchTerm) {
+    updatedTasks = updatedTasks.filter((task) => task.title.toLowerCase().includes(searchTerm.toLowerCase()));
+  }
   const taskPromises = updatedTasks.map(async (task) => {
     task.status = TASK_STATUS[task.status.toUpperCase()] || task.status;
     const taskId = task.id;
@@ -159,10 +163,10 @@ const fetchPaginatedTasks = async ({ status = "", size = TASK_SIZE, page, next,
   }
 };
 
-const fetchTasks = async () => {
+const fetchTasks = async (searchTerm) => {
   try {
     const tasksSnapshot = await tasksModel.get();
-    const taskList = await getBuiltTasks(tasksSnapshot);
+    const taskList = await getBuiltTasks(tasksSnapshot, searchTerm);
     return taskList;
   } catch (err) {
     logger.error("error getting tasks", err);
@@ -469,4 +473,5 @@ module.exports = {
   addDependency,
   fetchTaskByIssueId,
   fetchPaginatedTasks,
+  getBuiltTasks,
 };

test/integration/tasks.test.js

@@ -261,6 +261,46 @@ describe("Tasks", function () {
       expect(previousPageResponse.body).to.have.property("prev");
       expect(previousPageResponse.body.tasks).to.have.length(1);
     });
+    it("Should get tasks filtered by search term", function (done) {
+      const searchTerm = "task";
+      chai
+        .request(app)
+        .get("/tasks?q=searchTerm:task")
+        .end((err, res) => {
+          if (err) {
+            return done(err);
+          }
+          expect(res).to.have.status(200);
+          expect(res.body).to.be.a("object");
+          expect(res.body.message).to.equal("Filter tasks returned successfully!");
+          expect(res.body.tasks).to.be.a("array");
+
+          const matchingTasks = res.body.tasks;
+          matchingTasks.forEach((task) => {
+            expect(task.title.toLowerCase()).to.include(searchTerm.toLowerCase());
+          });
+          expect(matchingTasks).to.have.length(3);
+
+          return done();
+        });
+    });
+    it("Should get tasks filtered by search term and handle no tasks found", function (done) {
+      chai
+        .request(app)
+        .get(`/tasks?q=searchTerm:random1`)
+        .end((err, res) => {
+          if (err) {
+            return done(err);
+          }
+
+          expect(res).to.have.status(404);
+          expect(res.body).to.be.a("object");
+          expect(res.body.message).to.equal("No tasks found.");
+          expect(res.body.tasks).to.be.a("array");
+          expect(res.body.tasks).to.have.lengthOf(0);
+          return done();
+        });
+    });
   });
 
   describe("GET /tasks/:id/details", function () {

test/unit/middlewares/tasks-validator.test.js

@@ -347,4 +347,40 @@ describe("getTasks validator", function () {
     await getTasksValidator(req, res, nextMiddlewareSpy);
     expect(nextMiddlewareSpy.callCount).to.be.equal(1);
   });
+  it("should pass the request when a valid query is provided", async function () {
+    const req = {
+      query: {
+        dev: "true",
+        size: 3,
+        page: 0,
+        status: TASK_STATUS.ASSIGNED,
+        q: "searchterm:apple",
+      },
+    };
+    const res = {};
+    const nextMiddlewareSpy = Sinon.spy();
+    await getTasksValidator(req, res, nextMiddlewareSpy);
+    expect(nextMiddlewareSpy.callCount).to.be.equal(1);
+  });
+  it("should fail the request when an invalid query is provided", async function () {
+    const req = {
+      query: {
+        dev: "true",
+        size: 3,
+        page: 0,
+        status: TASK_STATUS.ASSIGNED,
+        q: "invalidkey:value",
+      },
+    };
+    const res = {
+      boom: {
+        badRequest: (message) => {
+          expect(message).to.equal('"q" contains an invalid value');
+        },
+      },
+    };
+    const nextMiddlewareSpy = Sinon.spy();
+    await getTasksValidator(req, res, nextMiddlewareSpy);
+    expect(nextMiddlewareSpy.callCount).to.be.equal(0);
+  });
 });

test/unit/models/tasks.test.js

@@ -9,7 +9,7 @@ const { expect } = chai;
 const cleanDb = require("../../utils/cleanDb");
 const tasksData = require("../../fixtures/tasks/tasks")();
 const tasks = require("../../../models/tasks");
-const { addDependency, updateTask } = require("../../../models/tasks");
+const { addDependency, updateTask, getBuiltTasks } = require("../../../models/tasks");
 const firestore = require("../../../utils/firestore");
 const { TASK_STATUS } = require("../../../constants/tasks");
 const dependencyModel = firestore.collection("TaskDependencies");
@@ -91,6 +91,22 @@ describe("tasks", function () {
         expect(task).to.contain.all.keys(sameTask);
       });
     });
+    it("should fetch tasks filtered by search term", async function () {
+      const searchTerm = "task-dependency";
+      const tasksSnapshot = await tasksModel.get();
+      const result = await getBuiltTasks(tasksSnapshot, searchTerm);
+      expect(result).to.have.lengthOf(1);
+      result.forEach((task) => {
+        expect(task.title.toLowerCase()).to.include(searchTerm.toLowerCase());
+      });
+      expect(tasksData[5].title.includes(searchTerm));
+    });
+    it("should return empty array when no search term is found", async function () {
+      const searchTerm = "random";
+      const tasksSnapshot = await tasksModel.get();
+      const result = await getBuiltTasks(tasksSnapshot, searchTerm);
+      expect(result).to.have.lengthOf(0);
+    });
   });
 
   describe("paginatedTasks", function () {

test/unit/utils/parseSearchQuery.test.js

@@ -0,0 +1,42 @@
+const { expect } = require("chai");
+const { parseSearchQuery } = require("../../../utils/tasks");
+
+describe("parseSearchQuery", function () {
+  it("should parse a valid query string", function () {
+    const queryString = "searchterm:example+assignee:john.doe+status:in_progress";
+    const result = parseSearchQuery(queryString);
+
+    expect(result).to.deep.equal({
+      searchTerm: "example",
+      assignee: "john.doe",
+      status: "in_progress",
+    });
+  });
+
+  it("should handle an empty query string", function () {
+    const queryString = "";
+    const result = parseSearchQuery(queryString);
+
+    expect(result).to.deep.equal({});
+  });
+
+  it("should ignore unknown keys in the query string", function () {
+    const queryString = "searchterm:example+assignee:john.doe+category:work";
+    const result = parseSearchQuery(queryString);
+
+    expect(result).to.deep.equal({
+      searchTerm: "example",
+      assignee: "john.doe",
+    });
+  });
+
+  it("should handle query string with duplicate keys", function () {
+    const queryString = "searchterm:example+searchterm:test+assignee:john.doe";
+    const result = parseSearchQuery(queryString);
+
+    expect(result).to.deep.equal({
+      searchTerm: "test",
+      assignee: "john.doe",
+    });
+  });
+});

utils/tasks.js

@@ -80,9 +80,32 @@ const transformQuery = (dev = false, status = "", size, page) => {
   return { status: transformedStatus, dev: transformedDev, ...query };
 };
 
+const parseSearchQuery = (queryString) => {
+  const searchParams = {};
+  const queryParts = queryString.split("+");
+  queryParts.forEach((part) => {
+    const [key, value] = part.split(":");
+    switch (key.toLowerCase()) {
+      case "searchterm":
+        searchParams.searchTerm = value.toLowerCase();
+        break;
+      case "assignee":
+        searchParams.assignee = value.toLowerCase();
+        break;
+      case "status":
+        searchParams.status = value.toLowerCase();
+        break;
+      default:
+        break;
+    }
+  });
+  return searchParams;
+};
+
 module.exports = {
   fromFirestoreData,
   toFirestoreData,
   buildTasks,
   transformQuery,
+  parseSearchQuery,
 };