Resolved conflicts in users and task unit tests and task model.

Author: VinuB-Dev

controllers/tasks.js

@@ -13,6 +13,7 @@ const { updateUserStatusOnTaskUpdate, updateStatusOnTaskCompletion } = require("
 const dataAccess = require("../services/dataAccessLayer");
 const { parseSearchQuery } = require("../utils/tasks");
 const { addTaskCreatedAtAndUpdatedAtFields } = require("../services/tasks");
+const tasksService = require("../services/tasks");
 const { RQLQueryParser } = require("../utils/RQLParser");
 const { getMissedProgressUpdatesUsers } = require("../models/discordactions");
 const { logType } = require("../constants/logs");
@@ -134,7 +135,19 @@ const fetchPaginatedTasks = async (query) => {
 
 const fetchTasks = async (req, res) => {
   try {
-    const { status, page, size, prev, next, q: queryString, assignee, title, userFeatureFlag } = req.query;
+    const {
+      status,
+      page,
+      size,
+      prev,
+      next,
+      q: queryString,
+      assignee,
+      title,
+      userFeatureFlag,
+      orphaned,
+      dev,
+    } = req.query;
     const transformedQuery = transformQuery(status, size, page, assignee, title);
 
     if (queryString !== undefined) {
@@ -159,6 +172,28 @@ const fetchTasks = async (req, res) => {
       });
     }
 
+    const isOrphaned = orphaned === "true";
+    const isDev = dev === "true";
+    if (isOrphaned) {
+      if (!isDev) {
+        return res.boom.notFound("Route not found");
+      }
+      try {
+        const orphanedTasks = await tasksService.fetchOrphanedTasks();
+        if (!orphanedTasks || orphanedTasks.length === 0) {
+          return res.sendStatus(204);
+        }
+        const tasksWithRdsAssigneeInfo = await fetchTasksWithRdsAssigneeInfo(orphanedTasks);
+        return res.status(200).json({
+          message: "Orphan tasks fetched successfully",
+          data: tasksWithRdsAssigneeInfo,
+        });
+      } catch (error) {
+        logger.error("Error in getting tasks which were orphaned", error);
+        return res.boom.badImplementation(INTERNAL_SERVER_ERROR);
+      }
+    }
+
     const paginatedTasks = await fetchPaginatedTasks({ ...transformedQuery, prev, next, userFeatureFlag });
     return res.json({
       message: "Tasks returned successfully!",

middlewares/validators/tasks.js

@@ -193,6 +193,7 @@ const getTasksValidator = async (req, res, next) => {
         return value;
       }, "Invalid query format"),
     userFeatureFlag: joi.string().optional(),
+    orphaned: joi.boolean().optional(),
   });
 
   try {

models/tasks.js

@@ -4,7 +4,6 @@ const userModel = firestore.collection("users");
 const ItemModel = firestore.collection("itemTags");
 const dependencyModel = firestore.collection("taskDependencies");
 const userUtils = require("../utils/users");
-const { updateTaskStatusToDone } = require("../services/tasks");
 const { chunks } = require("../utils/array");
 const { DOCUMENT_WRITE_SIZE } = require("../constants/constants");
 const { fromFirestoreData, toFirestoreData, buildTasks } = require("../utils/tasks");
@@ -24,6 +23,42 @@ const {
 const { OLD_ACTIVE, OLD_BLOCKED, OLD_PENDING, OLD_COMPLETED } = TASK_STATUS_OLD;
 const { INTERNAL_SERVER_ERROR } = require("../constants/errorMessages");
 
+/**
+ * Update multiple tasks' status to DONE in one batch operation.
+ * @param {Object[]} tasksData - Tasks data to update, must contain 'id' and 'status' fields.
+ * @returns {Object} - Summary of the batch operation.
+ * @property {number} totalUpdatedStatus - Number of tasks that has their status updated to DONE.
+ * @property {number} totalOperationsFailed - Number of tasks that failed to update.
+ * @property {string[]} updatedTaskDetails - IDs of tasks that has their status updated to DONE.
+ * @property {string[]} failedTaskDetails - IDs of tasks that failed to update.
+ */
+const updateTaskStatusToDone = async (tasksData) => {
+  const batch = firestore.batch();
+  const tasksBatch = [];
+  const summary = {
+    totalUpdatedStatus: 0,
+    totalOperationsFailed: 0,
+    updatedTaskDetails: [],
+    failedTaskDetails: [],
+  };
+  tasksData.forEach((task) => {
+    const updateTaskData = { ...task, status: "DONE" };
+    batch.update(tasksModel.doc(task.id), updateTaskData);
+    tasksBatch.push(task.id);
+  });
+  try {
+    await batch.commit();
+    summary.totalUpdatedStatus += tasksData.length;
+    summary.updatedTaskDetails = [...tasksBatch];
+    return { ...summary };
+  } catch (err) {
+    logger.error("Firebase batch Operation Failed!");
+    summary.totalOperationsFailed += tasksData.length;
+    summary.failedTaskDetails = [...tasksBatch];
+    return { ...summary };
+  }
+};
+
 /**
  * Adds and Updates tasks
  *
@@ -747,5 +782,6 @@ module.exports = {
   updateTaskStatus,
   updateOrphanTasksStatus,
   markUnDoneTasksOfArchivedUsersBacklog,
+  updateTaskStatusToDone,
   fetchIncompleteTasksByUserIds,
 };

models/users.js

@@ -1084,6 +1084,24 @@ const updateUsersWithNewUsernames = async () => {
   }
 };
 
+/**
+ * Fetches users who are not in the Discord server.
+ * @returns {Promise<FirebaseFirestore.QuerySnapshot>} - A promise that resolves to a Firestore QuerySnapshot containing the users matching the criteria.
+ * @throws {Error} - Throws an error if the database query fails.
+ */
+const fetchUsersNotInDiscordServer = async () => {
+  try {
+    const usersNotInDiscordServer = await userModel
+      .where("roles.archived", "==", true)
+      .where("roles.in_discord", "==", false)
+      .get();
+    return usersNotInDiscordServer;
+  } catch (error) {
+    logger.error(`Error in getting users who are not in discord server:  ${error}`);
+    throw error;
+  }
+};
+
 module.exports = {
   archiveUsers,
   addOrUpdate,
@@ -1114,4 +1132,5 @@ module.exports = {
   fetchUserForKeyValue,
   getNonNickNameSyncedUsers,
   updateUsersWithNewUsernames,
+  fetchUsersNotInDiscordServer,
 };

services/tasks.js

@@ -2,33 +2,8 @@ const firestore = require("../utils/firestore");
 const tasksModel = firestore.collection("tasks");
 const { chunks } = require("../utils/array");
 const { DOCUMENT_WRITE_SIZE: FIRESTORE_BATCH_OPERATIONS_LIMIT } = require("../constants/constants");
-
-const updateTaskStatusToDone = async (tasksData) => {
-  const batch = firestore.batch();
-  const tasksBatch = [];
-  const summary = {
-    totalUpdatedStatus: 0,
-    totalOperationsFailed: 0,
-    updatedTaskDetails: [],
-    failedTaskDetails: [],
-  };
-  tasksData.forEach((task) => {
-    const updateTaskData = { ...task, status: "DONE" };
-    batch.update(tasksModel.doc(task.id), updateTaskData);
-    tasksBatch.push(task.id);
-  });
-  try {
-    await batch.commit();
-    summary.totalUpdatedStatus += tasksData.length;
-    summary.updatedTaskDetails = [...tasksBatch];
-    return { ...summary };
-  } catch (err) {
-    logger.error("Firebase batch Operation Failed!");
-    summary.totalOperationsFailed += tasksData.length;
-    summary.failedTaskDetails = [...tasksBatch];
-    return { ...summary };
-  }
-};
+const usersQuery = require("../models/users");
+const tasksQuery = require("../models/tasks");
 
 const addTaskCreatedAtAndUpdatedAtFields = async () => {
   const operationStats = {
@@ -83,7 +58,30 @@ const addTaskCreatedAtAndUpdatedAtFields = async () => {
   return operationStats;
 };
 
+const fetchOrphanedTasks = async () => {
+  try {
+    const userSnapshot = await usersQuery.fetchUsersNotInDiscordServer();
+
+    if (userSnapshot.empty) return [];
+
+    const userIds = userSnapshot.docs.map((doc) => doc.id);
+
+    const orphanedTasksQuerySnapshot = await tasksQuery.fetchIncompleteTasksByUserIds(userIds);
+
+    if (orphanedTasksQuerySnapshot.empty) {
+      return [];
+    }
+
+    const orphanedTasks = orphanedTasksQuerySnapshot.map((doc) => doc.data());
+
+    return orphanedTasks;
+  } catch (error) {
+    logger.error(`Error in getting tasks abandoned by users:  ${error}`);
+    throw error;
+  }
+};
+
 module.exports = {
-  updateTaskStatusToDone,
   addTaskCreatedAtAndUpdatedAtFields,
+  fetchOrphanedTasks,
 };

test/integration/tasks.test.js

@@ -25,7 +25,8 @@ const userDBModel = firestore.collection("users");
 const discordService = require("../../services/discordService");
 const { CRON_JOB_HANDLER } = require("../../constants/bot");
 const { logType } = require("../../constants/logs");
-
+const { INTERNAL_SERVER_ERROR } = require("../../constants/errorMessages");
+const tasksService = require("../../services/tasks");
 chai.use(chaiHttp);
 
 const appOwner = userData[3];
@@ -37,6 +38,10 @@ const { stubbedModelTaskProgressData } = require("../fixtures/progress/progresse
 const { convertDaysToMilliseconds } = require("../../utils/time");
 const { getDiscordMembers } = require("../fixtures/discordResponse/discord-response");
 const { generateCronJobToken } = require("../utils/generateBotToken");
+const {
+  usersData: abandonedUsersData,
+  tasksData: abandonedTasksData,
+} = require("../fixtures/abandoned-tasks/departed-users");
 
 const taskData = [
   {
@@ -1633,4 +1638,57 @@ describe("Tasks", function () {
       });
     });
   });
+
+  describe("GET /tasks?orphaned", function () {
+    beforeEach(async function () {
+      await cleanDb();
+      const userPromises = abandonedUsersData.map((user) => userDBModel.doc(user.id).set(user));
+      await Promise.all(userPromises);
+
+      const taskPromises = abandonedTasksData.map((task) => tasksModel.add(task));
+      await Promise.all(taskPromises);
+    });
+
+    afterEach(async function () {
+      sinon.restore();
+      await cleanDb();
+    });
+
+    it("should return 204 status when no users are archived", async function () {
+      await cleanDb();
+
+      const user = abandonedUsersData[2];
+      await userDBModel.add(user);
+
+      const task = abandonedTasksData[3];
+      await tasksModel.add(task);
+
+      const res = await chai.request(app).get("/tasks?dev=true&orphaned=true").set("Accept", "application/json");
+
+      expect(res).to.have.status(204);
+    });
+
+    it("should fetch tasks assigned to archived and non-discord users", async function () {
+      const res = await chai.request(app).get("/tasks?dev=true&orphaned=true");
+
+      expect(res).to.have.status(200);
+      expect(res.body).to.have.property("message").that.equals("Orphan tasks fetched successfully");
+      expect(res.body.data).to.be.an("array").with.lengthOf(2);
+    });
+
+    it("should fail if dev flag is not passed", async function () {
+      const res = await chai.request(app).get("/tasks?orphaned=true");
+      expect(res).to.have.status(404);
+      expect(res.body.message).to.be.equal("Route not found");
+    });
+
+    it("should handle errors gracefully if the database query fails", async function () {
+      sinon.stub(tasksService, "fetchOrphanedTasks").rejects(new Error(INTERNAL_SERVER_ERROR));
+
+      const res = await chai.request(app).get("/tasks?orphaned=true&dev=true");
+
+      expect(res).to.have.status(500);
+      expect(res.body.message).to.be.equal(INTERNAL_SERVER_ERROR);
+    });
+  });
 });

test/unit/models/tasks.test.js

@@ -357,7 +357,7 @@ describe("tasks", function () {
     });
   });
 
-  describe("fetchIncompleteTaskForUser", function () {
+  describe("fetchIncompleteTasksByUserIds", function () {
     beforeEach(async function () {
       await cleanDb();
 

test/unit/models/users.test.js

@@ -572,4 +572,44 @@ describe("users", function () {
       }
     });
   });
+
+  describe("fetchUsersNotInDiscordServer", function () {
+    beforeEach(async function () {
+      await cleanDb();
+
+      const taskPromises = abandonedUsersData.map((task) => userModel.add(task));
+      await Promise.all(taskPromises);
+    });
+
+    afterEach(async function () {
+      await cleanDb();
+      sinon.restore();
+    });
+
+    it("should fetch users not in discord server", async function () {
+      const usersNotInDiscordServer = await users.fetchUsersNotInDiscordServer();
+      expect(usersNotInDiscordServer.docs.length).to.be.equal(2);
+    });
+
+    it("should return an empty array if there are no users in the database", async function () {
+      await cleanDb();
+
+      const activeUser = abandonedUsersData[2];
+      await userModel.add(activeUser);
+
+      const usersNotInDiscordServer = await users.fetchUsersNotInDiscordServer();
+      expect(usersNotInDiscordServer.docs.length).to.be.equal(0);
+    });
+
+    it("should handle errors gracefully if the database query fails", async function () {
+      sinon.stub(users, "fetchUsersNotInDiscordServer").throws(new Error("Database query failed"));
+
+      try {
+        await users.fetchUsersNotInDiscordServer();
+        expect.fail("Expected function to throw an error");
+      } catch (error) {
+        expect(error.message).to.equal("Database query failed");
+      }
+    });
+  });
 });