issues resolved to display seprate

src/controllers/installationController.js

@@ -5565,6 +5565,163 @@ exports.getDisconnectedIssuesBySupportId = async (req, reply) => {
   }
 };
 
+exports.getResolvedIssuesBySupportId = async (req, reply) => {
+  try {
+    const { supportId, customerId } = req.params;
+
+    if (!supportId || !customerId) {
+      return reply.code(400).send({ error: "supportId and customerId are required" });
+    }
+
+    const supportRecord = await Support.findOne({ supportId }).lean();
+    if (!supportRecord) {
+      return reply.code(404).send({ message: "No support record found" });
+    }
+
+    const resolvedIssues = (supportRecord.resolvedIssues || []).filter(issue => issue.currentlyResolved !== false);
+    const hardwareSet = new Set();
+
+    for (const issue of resolvedIssues) {
+      if (issue.hardwareId) hardwareSet.add(issue.hardwareId);
+      if (issue.masterHardwareId) hardwareSet.add(issue.masterHardwareId);
+    }
+
+    const hardwareIds = [...hardwareSet];
+
+    const sensors = await Insensors.find({
+      customerId,
+      $or: [
+        { hardwareId: { $in: hardwareIds } },
+        { tankhardwareId: { $in: hardwareIds } }
+      ]
+    }).lean();
+
+    const sensorMap = {};
+    for (const sensor of sensors) {
+      if (sensor.hardwareId) sensorMap[sensor.hardwareId] = sensor;
+      if (sensor.tankhardwareId) sensorMap[sensor.tankhardwareId] = sensor;
+    }
+
+    const orders = await Order.find({ customerId }).lean();
+
+    const orderMap = {};
+    for (const order of orders) {
+      (order.master_connections || []).forEach(conn => {
+        if (conn.hardwareId) {
+          orderMap[conn.hardwareId] = {
+            masterName: conn.master_name || null,
+            location: conn.location || null
+          };
+        }
+      });
+    }
+
+    const slaveOrderMap = {};
+    for (const order of orders) {
+      (order.tank_connections || []).forEach(conn => {
+        if (conn.hardwareId) {
+          slaveOrderMap[conn.hardwareId] = {
+            location: conn.location || null,
+            typeOfWater: conn.typeOfWater || null
+          };
+        }
+      });
+    }
+
+    const masterMap = {};
+
+    for (const issue of resolvedIssues) {
+      const masterId = issue.masterHardwareId || issue.hardwareId;
+      const masterSensor = sensorMap[masterId];
+      if (!masterSensor || masterSensor.type !== "master") continue;
+
+      const enriched = orderMap[masterId] || {};
+
+      const masterEntry = {
+        hardwareId: masterSensor.hardwareId,
+        masterName: enriched.masterName || masterSensor.masterName || "",
+        location: enriched.location || masterSensor.location || "",
+        type: "master",
+        connected_status: "connected",
+        connected_gsm_date: masterSensor.connected_gsm_date,
+        connected_gsm_time: masterSensor.connected_gsm_time,
+        connected_lora_date: masterSensor.connected_lora_date,
+        connected_lora_time: masterSensor.connected_lora_time,
+        gsm_last_check_time: masterSensor.gsm_last_check_time,
+        gsm_last_disconnect_time: masterSensor.gsm_last_disconnect_time,
+        support_gsm_last_check_time: masterSensor.support_gsm_last_check_time,
+        support_lora_last_check_time: masterSensor.support_lora_last_check_time,
+        team_member_support_gsm_last_check_time: masterSensor.team_member_support_gsm_last_check_time,
+        team_member_support_lora_last_check_time: masterSensor.team_member_support_lora_last_check_time,
+        connected_slave_count: 0,
+        connected_slaves: [],
+        resolvedAt: issue.resolvedAt,
+        originalMovedAt: issue.originalMovedAt
+      };
+
+      const connectedSlaves = await Insensors.find({
+        connected_to: masterId,
+        type: "slave",
+        customerId
+      }).lean();
+
+      for (const slave of connectedSlaves) {
+        const slaveHardwareId = slave.tankhardwareId || slave.hardwareId;
+
+        const tankInfo = await Tank.findOne({
+          $or: [{ hardwareId: slaveHardwareId }, { tankhardwareId: slaveHardwareId }]
+        }).lean();
+
+        const slaveOrderInfo = slaveOrderMap[slaveHardwareId] || {};
+
+        const slaveEnriched = {
+          hardwareId: slaveHardwareId,
+          tankName: slave.tankName || tankInfo?.tankName || "",
+          location: slave.location || tankInfo?.tankLocation || slaveOrderInfo.location || "",
+          connected_status: "connected",
+          connected_lora_time: slave.connected_lora_time,
+          connected_lora_date: slave.connected_lora_date,
+          lora_last_check_time: slave.lora_last_check_time,
+          lora_last_disconnect_time: slave.lora_last_disconnect_time,
+          connected_to: slave.connected_to,
+          masterName: masterEntry.masterName,
+          type: "slave",
+          typeOfWater: slave.typeOfWater || tankInfo?.typeOfWater || slaveOrderInfo.typeOfWater || "",
+          tankHeight: slave.tankHeight,
+          support_lora_last_check_time: slave.support_lora_last_check_time,
+          team_member_support_lora_last_check_time: slave.team_member_support_lora_last_check_time
+        };
+
+        masterEntry.connected_slaves.push(slaveEnriched);
+        masterEntry.connected_slave_count++;
+      }
+
+      masterMap[masterSensor.hardwareId] = masterEntry;
+    }
+
+    // Format and attach comments
+    const comments = (supportRecord.comments || []).map(c => ({
+      text: c.text,
+      commentsTime: moment(c.createdAt).tz("Asia/Kolkata").format("DD-MM-YYYY HH:mm")
+    }));
+
+    for (const master of Object.values(masterMap)) {
+      master.comments = comments;
+    }
+
+    return reply.send({
+      status_code: 200,
+      supportId,
+      customerId,
+      totalResolved: Object.keys(masterMap).length,
+      resolvedIssues: Object.values(masterMap)
+    });
+  } catch (err) {
+    console.error("Error in getResolvedIssuesBySupportId:", err);
+    return reply.code(500).send({ error: "Internal Server Error" });
+  }
+};
+
 
 // exports.getRemoveConnectedMastersWithSlaves = async (req, reply) => {
 //   try {

src/routes/installationRoute.js

@@ -562,6 +562,24 @@ module.exports = function (fastify, opts, next) {
         },
         handler: installationController.getDisconnectedIssuesBySupportId,
       });
+
+      fastify.get("/api/getAllResolvedIsuues/:supportId/:customerId", {
+        schema: {
+          description: "Get All Resolved list for Support",
+          tags: ["Support"],
+          summary: "Get All Resolved list for Support",
+          params: {
+            type: "object",
+            properties: {
+              supportId: { type: "string" },
+              customerId: { type: "string" },
+            },
+            required: [ "supportId"],
+          },
+        },
+        handler: installationController.getResolvedIssuesBySupportId,
+      });
+
       fastify.put('/api/updateComments/:supportId', {
         schema: {
           description: "Update comments for a support record issue",