Merge pull request #1714 from Real-Dev-Squad/revert-1705-remove-scripting-code

Revert "Remove code- One-Time Script to Migrate Status from "COMPLETED" to "DONE" in taskModel Database"

Author: prakashchoudhary07

controllers/tasks.js

@@ -426,6 +426,16 @@ const assignTask = async (req, res) => {
   }
 };
 
+const updateStatus = async (req, res) => {
+  try {
+    const response = await tasks.updateTaskStatus();
+    return res.status(200).json(response);
+  } catch (error) {
+    logger.error("Error in migration scripts", error);
+    return res.boom.badImplementation(INTERNAL_SERVER_ERROR);
+  }
+};
+
 module.exports = {
   addNewTask,
   fetchTasks,
@@ -436,4 +446,5 @@ module.exports = {
   updateTaskStatus,
   overdueTasks,
   assignTask,
+  updateStatus,
 };

models/tasks.js

@@ -3,10 +3,14 @@ const tasksModel = firestore.collection("tasks");
 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");
 const { TASK_TYPE, TASK_STATUS, TASK_STATUS_OLD, TASK_SIZE } = require("../constants/tasks");
 const { IN_PROGRESS, NEEDS_REVIEW, IN_REVIEW, ASSIGNED, BLOCKED, SMOKE_TESTING, COMPLETED, SANITY_CHECK } = TASK_STATUS;
 const { OLD_ACTIVE, OLD_BLOCKED, OLD_PENDING, OLD_COMPLETED } = TASK_STATUS_OLD;
+const { INTERNAL_SERVER_ERROR } = require("../constants/errorMessages");
 
 /**
  * Adds and Updates tasks
@@ -575,6 +579,62 @@ const getOverdueTasks = async (days = 0) => {
   }
 };
 
+const updateTaskStatus = async () => {
+  try {
+    const snapshot = await tasksModel.where("status", "==", "COMPLETED").get();
+    const tasksStatusCompleted = [];
+    let summary = {
+      totalTasks: snapshot.size,
+      totalUpdatedStatus: 0,
+      totalOperationsFailed: 0,
+      updatedTaskDetails: [],
+      failedTaskDetails: [],
+    };
+
+    if (snapshot.size === 0) {
+      return summary;
+    }
+
+    snapshot.forEach((task) => {
+      const id = task.id;
+      const taskData = task.data();
+      tasksStatusCompleted.push({ ...taskData, id });
+    });
+    const taskStatusCompletedChunks = chunks(tasksStatusCompleted, DOCUMENT_WRITE_SIZE);
+
+    const updatedTasksPromises = await Promise.all(
+      taskStatusCompletedChunks.map(async (tasks) => {
+        const res = await updateTaskStatusToDone(tasks);
+        return {
+          totalUpdatedStatus: res.totalUpdatedStatus,
+          totalOperationsFailed: res.totalOperationsFailed,
+          updatedTaskDetails: res.updatedTaskDetails,
+          failedTaskDetails: res.failedTaskDetails,
+        };
+      })
+    );
+
+    updatedTasksPromises.forEach((res) => {
+      summary = {
+        ...summary,
+        totalUpdatedStatus: (summary.totalUpdatedStatus += res.totalUpdatedStatus),
+        totalOperationsFailed: (summary.totalOperationsFailed += res.totalOperationsFailed),
+        updatedTaskDetails: [...summary.updatedTaskDetails, ...res.updatedTaskDetails],
+        failedTaskDetails: [...summary.failedTaskDetails, ...res.failedTaskDetails],
+      };
+    });
+
+    if (summary.totalOperationsFailed === summary.totalTasks) {
+      throw Error(INTERNAL_SERVER_ERROR);
+    }
+
+    return summary;
+  } catch (error) {
+    logger.error(`Error in updating task status:  ${error}`);
+    throw error;
+  }
+};
+
 module.exports = {
   updateTask,
   fetchTasks,
@@ -591,4 +651,5 @@ module.exports = {
   fetchPaginatedTasks,
   getBuiltTasks,
   getOverdueTasks,
+  updateTaskStatus,
 };

routes/tasks.js

@@ -40,4 +40,6 @@ router.patch(
 );
 router.patch("/assign/self", authenticate, invalidateCache({ invalidationKeys: [ALL_TASKS] }), tasks.assignTask);
 
+router.post("/migration", authenticate, authorizeRoles([SUPERUSER]), tasks.updateStatus);
+
 module.exports = router;

services/tasks.js

@@ -0,0 +1,31 @@
+const firestore = require("../utils/firestore");
+const tasksModel = firestore.collection("tasks");
+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 };
+  }
+};
+module.exports = {
+  updateTaskStatusToDone,
+};

test/integration/tasks.test.js

@@ -3,6 +3,7 @@ const sinon = require("sinon");
 const { expect } = chai;
 const chaiHttp = require("chai-http");
 
+const firestore = require("../../utils/firestore");
 const app = require("../../server");
 const tasks = require("../../models/tasks");
 const authService = require("../../services/authService");
@@ -1021,4 +1022,51 @@ describe("Tasks", function () {
       expect(res.body.message).to.be.equal("No overdue tasks found");
     });
   });
+
+  describe("POST /tasks/migration", function () {
+    it("Should update status COMPLETED to DONE successful", async function () {
+      const taskData1 = { status: "COMPLETED" };
+      await firestore.collection("tasks").doc("updateTaskStatus1").set(taskData1);
+      const res = await chai.request(app).post("/tasks/migration").set("cookie", `${cookieName}=${superUserJwt}`);
+      expect(res).to.have.status(200);
+      expect(res.body.totalTasks).to.be.equal(1);
+      expect(res.body.totalUpdatedStatus).to.be.equal(1);
+      expect(res.body.updatedTaskDetails).to.deep.equal(["updateTaskStatus1"]);
+      expect(res.body.totalOperationsFailed).to.be.equal(0);
+      expect(res.body.failedTaskDetails).to.deep.equal([]);
+    });
+
+    it("Should not update if not found any COMPLETED task status ", async function () {
+      const res = await chai.request(app).post("/tasks/migration").set("cookie", `${cookieName}=${superUserJwt}`);
+      expect(res).to.have.status(200);
+      expect(res.body.totalTasks).to.be.equal(0);
+      expect(res.body.totalUpdatedStatus).to.be.equal(0);
+      expect(res.body.updatedTaskDetails).to.deep.equal([]);
+      expect(res.body.totalOperationsFailed).to.be.equal(0);
+      expect(res.body.failedTaskDetails).to.deep.equal([]);
+    });
+
+    it("should throw an error if firestore batch operations fail", async function () {
+      const stub = sinon.stub(firestore, "batch");
+      stub.returns({
+        update: function () {},
+        commit: function () {
+          throw new Error("Firestore batch commit failed!");
+        },
+      });
+      const taskData1 = { status: "COMPLETED" };
+      await firestore.collection("tasks").doc("updateTaskStatus1").set(taskData1);
+      const res = await chai.request(app).post("/tasks/migration").set("cookie", `${cookieName}=${superUserJwt}`);
+      expect(res.status).to.equal(500);
+      const response = res.body;
+      expect(response.message).to.be.equal("An internal server error occurred");
+    });
+
+    it("Should return 401 if not super_user", async function () {
+      const nonSuperUserId = await addUser(appOwner);
+      const nonSuperUserJwt = authService.generateAuthToken({ userId: nonSuperUserId });
+      const res = await chai.request(app).post("/tasks/migration").set("cookie", `${cookieName}=${nonSuperUserJwt}`);
+      expect(res).to.have.status(401);
+    });
+  });
 });

test/unit/models/tasks.test.js

@@ -5,6 +5,7 @@
 /* eslint-disable security/detect-object-injection */
 
 const chai = require("chai");
+const sinon = require("sinon");
 const { expect } = chai;
 const cleanDb = require("../../utils/cleanDb");
 const tasksData = require("../../fixtures/tasks/tasks")();
@@ -304,4 +305,45 @@ describe("tasks", function () {
       expect(usersWithOverdueTasks.length).to.be.equal(4);
     });
   });
+
+  describe("update task status", function () {
+    beforeEach(async function () {
+      const addTasksPromises = [];
+      tasksData.forEach((task) => {
+        const taskData = {
+          ...task,
+          status: "COMPLETED",
+        };
+        addTasksPromises.push(tasksModel.add(taskData));
+      });
+
+      await Promise.all(addTasksPromises);
+    });
+
+    afterEach(function () {
+      sinon.restore();
+    });
+
+    it("Should update task status COMPLETED to DONE", async function () {
+      const res = await tasks.updateTaskStatus();
+      expect(res.totalTasks).to.be.equal(8);
+      expect(res.totalUpdatedStatus).to.be.equal(8);
+    });
+
+    it("should throw an error if firebase batch operation fails", async function () {
+      const stub = sinon.stub(firestore, "batch");
+      stub.returns({
+        update: function () {},
+        commit: function () {
+          throw new Error("Firestore batch update failed");
+        },
+      });
+      try {
+        await tasks.updateTaskStatus();
+      } catch (error) {
+        expect(error).to.be.an.instanceOf(Error);
+        expect(error.message).to.equal("An internal server error occurred");
+      }
+    });
+  });
 });

test/unit/services/tasks.test.js

@@ -0,0 +1,74 @@
+const Sinon = require("sinon");
+const { expect } = require("chai");
+
+const firestore = require("../../../utils/firestore");
+const tasksModel = firestore.collection("tasks");
+const cleanDb = require("../../utils/cleanDb");
+const taskDataArray = require("../../fixtures/tasks/tasks")();
+const { updateTaskStatusToDone } = require("../../../services/tasks");
+
+describe("Tasks services", function () {
+  describe("task status COMPLETED to DONE in bulk", function () {
+    const tasks = [];
+    const taskDetails = [];
+    beforeEach(async function () {
+      const addTasksPromises = [];
+      taskDataArray.forEach((task) => {
+        const taskData = {
+          ...task,
+          status: "COMPLETED",
+        };
+        addTasksPromises.push(tasksModel.add(taskData));
+      });
+
+      await Promise.all(addTasksPromises);
+
+      tasks.length = 0;
+      taskDetails.length = 0;
+
+      const snapshot = await tasksModel.where("status", "==", "COMPLETED").get();
+
+      snapshot.forEach((task) => {
+        const id = task.id;
+        const taskData = task.data();
+        tasks.push({ ...taskData, id });
+        taskDetails.push(id);
+      });
+    });
+
+    afterEach(async function () {
+      await cleanDb();
+      Sinon.restore();
+    });
+
+    it("successfully updated task status COMPLETED To DONE", async function () {
+      const res = await updateTaskStatusToDone(tasks);
+
+      expect(res).to.deep.equal({
+        totalUpdatedStatus: 8,
+        totalOperationsFailed: 0,
+        updatedTaskDetails: taskDetails,
+        failedTaskDetails: [],
+      });
+    });
+
+    it("should throw an error if firebase batch operation fails", async function () {
+      const batchStub = Sinon.stub(firestore, "batch");
+      batchStub.returns({
+        update: function () {},
+        commit: function () {
+          throw new Error("Firebase batch operation failed");
+        },
+      });
+
+      const res = await updateTaskStatusToDone(tasks);
+
+      expect(res).to.deep.equal({
+        totalUpdatedStatus: 0,
+        totalOperationsFailed: 8,
+        updatedTaskDetails: [],
+        failedTaskDetails: taskDetails,
+      });
+    });
+  });
+});