Adds a utils function to parse query params

controllers/tasks.js

@@ -7,15 +7,14 @@ const { OLD_ACTIVE, OLD_BLOCKED, OLD_PENDING } = TASK_STATUS_OLD;
 const { IN_PROGRESS, BLOCKED, SMOKE_TESTING, ASSIGNED } = TASK_STATUS;
 const { INTERNAL_SERVER_ERROR, SOMETHING_WENT_WRONG } = require("../constants/errorMessages");
 const dependencyModel = require("../models/tasks");
-const { transformQuery } = require("../utils/tasks");
+const { transformQuery, transformTasksUsersQuery } = require("../utils/tasks");
 const { getPaginatedLink } = require("../utils/helper");
 const { updateUserStatusOnTaskUpdate, updateStatusOnTaskCompletion } = require("../models/userStatus");
 const dataAccess = require("../services/dataAccessLayer");
 const { parseSearchQuery } = require("../utils/tasks");
 const { addTaskCreatedAtAndUpdatedAtFields } = require("../services/tasks");
 const { RQLQueryParser } = require("../utils/RQLParser");
 const { getMissedProgressUpdatesUsers } = require("../models/discordactions");
-const { daysOfWeek } = require("../constants/constants");
 const { logType } = require("../constants/logs");
 
 /**
@@ -484,17 +483,21 @@ const getUsersHandler = async (req, res) => {
   try {
     const { size, cursor, q: queryString } = req.query;
     const rqlParser = new RQLQueryParser(queryString);
-    const { "days-count": daysGap, weekday, date, status } = rqlParser.getFilterQueries();
-    if (!!status && status.length === 1 && status[0].value === tasksUsersStatus.MISSED_UPDATES) {
-      if (daysGap && daysGap > 1) {
-        return res.boom.badRequest("number of days gap provided cannot be greater than 1");
-      }
+    const filterQueries = rqlParser.getFilterQueries();
+    const {
+      dateGap,
+      weekdayList,
+      dateList,
+      status,
+      size: transformedSize,
+    } = transformTasksUsersQuery({ ...filterQueries, size });
+    if (status === tasksUsersStatus.MISSED_UPDATES) {
       const response = await getMissedProgressUpdatesUsers({
         cursor: cursor,
-        size: size && Number.parseInt(size),
-        excludedDates: date?.map((date) => Number.parseInt(date.value)),
-        excludedDays: weekday?.map((day) => daysOfWeek[day.value]),
-        dateGap: !!daysGap && daysGap.length === 1 ? Number.parseInt(daysGap[0].value) : null,
+        size: transformedSize,
+        excludedDates: dateList,
+        excludedDays: weekdayList,
+        dateGap: dateGap,
       });
 
       if (response.error) {
@@ -504,7 +507,7 @@ const getUsersHandler = async (req, res) => {
         .status(200)
         .json({ message: "Discord details of users with status missed updates fetched successfully", data: response });
     } else {
-      return res.boom.badRequest("Unknown type and query");
+      return res.boom.badRequest(`Invalid status: ${status}`);
     }
   } catch (error) {
     const taskRequestLog = {

middlewares/validators/tasks.js

@@ -205,7 +205,7 @@ const getUsersValidator = async (req, res, next) => {
   const queryParamsSchema = joi.object().keys({
     cursor: joi.string().optional(),
     q: joi.string().optional(),
-    size: joi.number().integer().min(1).max(2013),
+    size: joi.number().integer().min(1).max(2000),
   });
   const filtersSchema = joi.object().keys({
     status: joi
@@ -225,6 +225,7 @@ const getUsersValidator = async (req, res, next) => {
           operator: joi.string().valid(Operators.EXCLUDE),
         })
       )
+      .max(1)
       .optional(),
     weekday: joi
       .array()
@@ -234,6 +235,7 @@ const getUsersValidator = async (req, res, next) => {
           operator: joi.string().valid(Operators.EXCLUDE),
         })
       )
+      .max(7)
       .optional(),
     date: joi
       .array()
@@ -243,6 +245,7 @@ const getUsersValidator = async (req, res, next) => {
           operator: joi.string().valid(Operators.EXCLUDE),
         })
       )
+      .max(20)
       .optional(),
   });
 

test/unit/utils/tasks.test.js

@@ -0,0 +1,70 @@
+const { expect } = require("chai");
+const { transformTasksUsersQuery } = require("../../../utils/tasks");
+const { RQLQueryParser } = require("../../../utils/RQLParser");
+const { tasksUsersStatus } = require("../../../constants/tasks");
+
+describe("Utils | Tasks", function () {
+  describe("transformTasksUsersQuery", function () {
+    it("should correctly transform given queries", function () {
+      const rqlParser = new RQLQueryParser(
+        `status:${tasksUsersStatus.MISSED_UPDATES} -weekday:sun -date:231423432 -days-count:4`
+      );
+      const filterQueries = rqlParser.getFilterQueries();
+      const result = transformTasksUsersQuery({ ...filterQueries, size: 40 });
+      const { dateGap, status, size, weekdayList, dateList } = result;
+      expect(status).to.equal(tasksUsersStatus.MISSED_UPDATES);
+      expect(weekdayList).to.deep.equal([0]);
+      expect(dateList).to.deep.equal([231423432]);
+      expect(dateGap).to.equal(4);
+      expect(size).to.equal(40);
+    });
+
+    it("should correctly transform multiple queries", function () {
+      const rqlParser = new RQLQueryParser(
+        `status:${tasksUsersStatus.MISSED_UPDATES} -weekday:sun -weekday:mon -date:231423432 -date:231423433434 -days-count:4`
+      );
+      const filterQueries = rqlParser.getFilterQueries();
+      const result = transformTasksUsersQuery({ ...filterQueries, size: 40 });
+      const { dateGap, status, size, weekdayList, dateList } = result;
+      expect(status).to.equal(tasksUsersStatus.MISSED_UPDATES);
+      expect(weekdayList).to.deep.equal([0, 1]);
+      expect(dateList).to.deep.equal([231423432, 231423433434]);
+      expect(dateGap).to.deep.equal(4);
+      expect(size).to.deep.equal(40);
+    });
+
+    it("should return undefined for empty query values", function () {
+      const result = transformTasksUsersQuery({});
+      const { dateGap, status, size, weekdayList, dateList } = result;
+      expect(dateGap).to.equal(undefined);
+      expect(status).to.equal(undefined);
+      expect(size).to.equal(undefined);
+      expect(weekdayList).to.equal(undefined);
+      expect(dateList).to.equal(undefined);
+    });
+
+    it("should handle null queries gracefully", function () {
+      const result = transformTasksUsersQuery(null);
+      const { dateGap, status, size, weekdayList, dateList } = result;
+      expect(dateGap).to.equal(undefined);
+      expect(status).to.equal(undefined);
+      expect(size).to.equal(undefined);
+      expect(weekdayList).to.equal(undefined);
+      expect(dateList).to.equal(undefined);
+    });
+    it("should handle undefined queries gracefully", function () {
+      const result = transformTasksUsersQuery(undefined);
+      const { dateGap, status, size, weekdayList, dateList } = result;
+      expect(dateGap).to.equal(undefined);
+      expect(status).to.equal(undefined);
+      expect(size).to.equal(undefined);
+      expect(weekdayList).to.equal(undefined);
+      expect(dateList).to.equal(undefined);
+    });
+    it("should ignore unexpected query keys", function () {
+      const queries = { unexpectedKey: [{ value: "someValue" }] };
+      const result = transformTasksUsersQuery(queries);
+      expect(result).to.not.have.property("unexpectedKey");
+    });
+  });
+});

utils/tasks.js

@@ -2,6 +2,7 @@ const { getUsername, getUserId, getParticipantUsernames, getParticipantUserIds }
 const { TASK_TYPE, MAPPED_TASK_STATUS, COMPLETED_TASK_STATUS, TASK_STATUS } = require("../constants/tasks");
 const fireStore = require("../utils/firestore");
 const tasksModel = fireStore.collection("tasks");
+const { daysOfWeek } = require("../constants/constants");
 
 const fromFirestoreData = async (task) => {
   if (!task) {
@@ -121,11 +122,37 @@ const buildTasksQueryForMissedUpdates = (size) => {
     .limit(size);
 };
 
+const transformTasksUsersQuery = (queries) => {
+  if (!queries) return {};
+  const { "days-count": dateGap, weekday, date, status, size } = queries;
+  let transformedStatus;
+  if (status && status.length === 1 && status[0].value) {
+    transformedStatus = status[0].value;
+  }
+  let transformedSize;
+  if (size) {
+    transformedSize = Number.parseInt(size);
+  }
+  let transformedDateGap;
+  if (dateGap && dateGap.length === 1) {
+    transformedDateGap = Number.parseInt(dateGap[0].value);
+  }
+  let dateList;
+  if (date) {
+    dateList = date.map((date) => Number.parseInt(date.value));
+  }
+  let weekdayList;
+  if (weekday) {
+    weekdayList = weekday.map((day) => daysOfWeek[day.value]);
+  }
+  return { dateGap: transformedDateGap, status: transformedStatus, size: transformedSize, weekdayList, dateList };
+};
 module.exports = {
   fromFirestoreData,
   toFirestoreData,
   buildTasks,
   transformQuery,
   parseSearchQuery,
   buildTasksQueryForMissedUpdates,
+  transformTasksUsersQuery,
 };