Implemented test run editor's bulk test case selection

backend/index.js

@@ -92,10 +92,14 @@ app.use("/runs", runDeleteRoute);
 // "/runcases"
 const runCaseIndexRoute = require("./routes/runcases/index")(sequelize);
 const runCaseNewRoute = require("./routes/runcases/new")(sequelize);
+const runCaseBuldNewRoute = require("./routes/runcases/bulkNew")(sequelize);
 const runCaseDeleteRoute = require("./routes/runcases/delete")(sequelize);
+const runCaseBulkDeleteRoute = require("./routes/runcases/bulkDelete")(sequelize);
 app.use("/runcases", runCaseIndexRoute);
 app.use("/runcases", runCaseNewRoute);
+app.use("/runcases", runCaseBuldNewRoute);
 app.use("/runcases", runCaseDeleteRoute);
+app.use("/runcases", runCaseBulkDeleteRoute);
 
 const PORT = process.env.PORT || 3001;
 app.listen(PORT, () => {

backend/routes/runcases/bulkDelete.js

@@ -0,0 +1,49 @@
+const express = require("express");
+const router = express.Router();
+const defineRunCase = require("../../models/runCases");
+const { DataTypes, Op } = require("sequelize");
+
+module.exports = function (sequelize) {
+  const RunCase = defineRunCase(sequelize, DataTypes);
+
+  router.post("/bulkdelete", async (req, res) => {
+    const recordsToDelete = req.body;
+
+    try {
+      const existingRunCases = await RunCase.findAll({
+        where: {
+          [Op.or]: recordsToDelete.map((condition) => ({
+            runId: condition.runId,
+            caseId: condition.caseId,
+          })),
+        },
+      });
+
+      console.log("######bulkDelete")
+      console.log(recordsToDelete)
+
+      if (existingRunCases.length === 0) {
+        return res.status(400).send("No records found to delete");
+      }
+
+      // await RunCase.destroy({
+      //   where: recordsToDelete,
+      // });
+      await RunCase.destroy({
+        where: {
+          [Op.or]: recordsToDelete.map((condition) => ({
+            runId: condition.runId,
+            caseId: condition.caseId,
+          })),
+        },
+      });
+
+      res.status(200).send("Records deleted successfully");
+    } catch (error) {
+      console.error("Error deleting run cases:", error);
+      res.status(500).send("Internal Server Error");
+    }
+  });
+
+  return router;
+};

backend/routes/runcases/bulkNew.js

@@ -0,0 +1,47 @@
+const express = require("express");
+const router = express.Router();
+const defineRunCase = require("../../models/runCases");
+const { DataTypes, Op } = require("sequelize");
+
+module.exports = function (sequelize) {
+  const RunCase = defineRunCase(sequelize, DataTypes);
+
+  router.post("/bulknew", async (req, res) => {
+    const recordsToCreate = req.body;
+
+    try {
+      const existingRunCases = await RunCase.findAll({
+        where: {
+          [Op.or]: recordsToCreate.map((record) => ({
+            runId: record.runId,
+            caseId: record.caseId,
+          })),
+        },
+      });
+
+      // Filter out records that already exist
+      const recordsToCreateFiltered = recordsToCreate.filter((record) => {
+        return !existingRunCases.some(
+          (existingRecord) =>
+            existingRecord.runId === record.runId &&
+            existingRecord.caseId === record.caseId
+        );
+      });
+      console.log(recordsToCreateFiltered)
+      const newRunCases = await RunCase.bulkCreate(
+        recordsToCreateFiltered.map((record) => ({
+          runId: record.runId,
+          caseId: record.caseId,
+          status: 0,
+        }))
+      );
+
+      res.json(newRunCases);
+    } catch (error) {
+      console.error(error);
+      res.status(500).send("Internal Server Error");
+    }
+  });
+
+  return router;
+};

backend/routes/runcases/new.js

@@ -11,6 +11,18 @@ module.exports = function (sequelize) {
     const caseId = req.query.caseId;
 
     try {
+      // Check if the record already exists
+      const existingRunCase = await RunCase.findOne({
+        where: {
+          runId: runId,
+          caseId: caseId
+        }
+      });
+
+      if (existingRunCase) {
+        return res.status(400).send("Record already exists");
+      }
+
       const newRunCase = await RunCase.create(
         {
           runId: runId,