long Term issues on master slave details

src/controllers/installationController.js

@@ -8262,6 +8262,155 @@ exports.getLongTermCustomerDetails = async (req, reply) => {
   }
 };
 
+exports.getLongTermIssuesByCustomer = async (req, reply) => {
+  try {
+    const { supportId, customerId } = req.params;
+
+    if (!supportId || !customerId) {
+      return reply.code(400).send({ error: "supportId and customerId are required in path params" });
+    }
+
+    const support = await Support.findOne({ supportId }).lean();
+    if (!support) return reply.code(404).send({ message: "Support record not found" });
+
+    const longTermIssues = (support.categorizedIssues || []).filter(i => i.category === "LongTerm Issues");
+    if (!longTermIssues.length) return reply.code(404).send({ message: "No Long Term Issues found" });
+
+    const hardwareIds = [...new Set(longTermIssues.map(i => i.hardwareId).filter(Boolean))];
+    const sensors = await Insensors.find({
+      customerId,
+      hardwareId: { $in: hardwareIds }
+    }).lean();
+
+    if (!sensors.length) return reply.code(404).send({ message: "No sensors found for this customer" });
+
+    const orders = await Order.find({ customerId }).lean();
+    const orderMap = {};
+    for (const order of orders) {
+      for (const conn of order.master_connections || []) {
+        const trimmedId = (conn.hardwareId || "").trim();
+        if (trimmedId) {
+          orderMap[trimmedId] = {
+            masterName: conn.master_name?.trim() || "",
+            location: conn.location?.trim() || ""
+          };
+        }
+      }
+    }
+
+    const issueMap = {};
+    for (const issue of longTermIssues) {
+      issueMap[issue.hardwareId] = issue;
+    }
+
+    const disconnectedIssues = [];
+    for (const master of sensors.filter(s => s.type === "master")) {
+      const slaves = await Insensors.find({ connected_to: master.hardwareId, customerId }).lean();
+      const latestIotData = await IotData.findOne({ hardwareId: master.hardwareId }).sort({ date: -1 }).lean();
+      const now = moment.tz("Asia/Kolkata");
+
+      let gsmConnected = false;
+      if (latestIotData?.date) {
+        const gsmTime = moment.tz(latestIotData.date, "Asia/Kolkata");
+        gsmConnected = now.diff(gsmTime, "minutes") <= 1;
+      }
+
+      const slaveDetails = await Promise.all(slaves.map(async (slave) => {
+        const slaveHardwareId = slave.tankhardwareId?.trim();
+        const matchedTank = latestIotData?.tanks?.find(tank => tank.tankhardwareId === slaveHardwareId);
+
+        let loraConnected = false;
+        if (matchedTank?.date && matchedTank?.tankHeight !== "0") {
+          const tankTime = moment.tz(matchedTank.date, "Asia/Kolkata");
+          loraConnected = now.diff(tankTime, "minutes") <= 1;
+        }
+
+        const tankInfo = await Tank.findOne({
+          $or: [
+            { hardwareId: slaveHardwareId },
+            { tankhardwareId: slaveHardwareId }
+          ]
+        }).lean();
+
+        const slaveComments = (support.comments || []).filter(
+          comment => comment.hardwareId === slave.hardwareId && comment.customerId === customerId
+        ).map(c => ({
+          text: c.text,
+          commentsTime: c.createdAt ? moment(c.createdAt).tz("Asia/Kolkata").format("DD-MM-YYYY HH:mm") : null
+        }));
+
+        return {
+          hardwareId: slave.tankhardwareId,
+          tankName: slave.tankName || "",
+          location: slave.tankLocation || "",
+          connected_status: loraConnected ? "connected" : "disconnected",
+          connected_to: slave.connected_to || "",
+          gsm_last_check_time: slave.gsm_last_check_time || null,
+          gsm_last_disconnect_time: slave.gsm_last_disconnect_time || null,
+          lora_last_disconnect_time: slave.lora_last_disconnect_time || null,
+          connected_gsm_date: slave.connected_gsm_date || "",
+          connected_gsm_time: slave.connected_gsm_time || "",
+          connected_lora_date: slave.connected_lora_date || "",
+          connected_lora_time: slave.connected_lora_time || "",
+          support_lora_last_check_time: slave.support_lora_last_check_time || null,
+          masterName: orderMap[master.hardwareId?.trim()]?.masterName || "",
+          type: "slave",
+          typeOfWater: tankInfo?.typeOfWater || "",
+          outDoor_status: slave.outDoor_status || "inprogress"
+        };
+      }));
+
+      const masterComments = (support.comments || []).filter(
+        comment => comment.hardwareId === master.hardwareId && comment.customerId === customerId
+      ).map(c => ({
+        text: c.text,
+        commentsTime: c.createdAt ? moment(c.createdAt).tz("Asia/Kolkata").format("DD-MM-YYYY HH:mm") : null
+      }));
+
+      const orderDetails = orderMap[master.hardwareId?.trim()] || {};
+      const issue = issueMap[master.hardwareId];
+
+      disconnectedIssues.push({
+        hardwareId: master.hardwareId,
+        masterName: orderDetails.masterName || "",
+        location: orderDetails.location || "",
+        type: "master",
+        connected_status: gsmConnected ? "connected" : "disconnected",
+        connected_slave_count: slaveDetails.length,
+        gsm_last_check_time: master.gsm_last_check_time || null,
+        gsm_last_disconnect_time: master.gsm_last_disconnect_time || null,
+        lora_last_disconnect_time: master.lora_last_disconnect_time || null,
+        connected_gsm_date: master.connected_gsm_date || "",
+        connected_gsm_time: master.connected_gsm_time || "",
+        connected_lora_date: master.connected_lora_date || "",
+        connected_lora_time: master.connected_lora_time || "",
+        support_gm_last_check_time: master.support_gsm_last_check_time || null,
+        connected_slaves: slaveDetails,
+        comments: masterComments,
+        outDoor_status: master.outDoor_status || "inprogress",
+        movedAt: issue?.movedAt || null,
+        resolvedAt: issue?.resolvedAt || null,
+        category: issue?.category || "Uncategorized",
+        hardwareList: master.hardwareList || {},
+        assignedTo: issue?.assignedTo || null
+      });
+    }
+
+    return reply.send({
+      status_code: 200,
+      supportId,
+      customerId,
+      totalMasters: disconnectedIssues.length,
+      disconnectedIssues
+    });
+
+  } catch (err) {
+    console.error("❌ Error in getLongTermIssuesByCustomer:", err);
+    return reply.code(500).send({ error: "Internal server error" });
+  }
+};
+
+
 // const bcrypt = require("bcrypt");
 
 exports.createTeamMemberSupport = async (req, reply) => {

src/routes/installationRoute.js

@@ -705,6 +705,25 @@ module.exports = function (fastify, opts, next) {
         },
         handler: installationController.getLongTermCustomerDetails,
       });
+
+       fastify.get("/api/longTermissusesbuildingdetails/:supportId/:customerId", {
+        schema: {
+          description: "Long Term Issues the master and slave details move for Support",
+          tags: ["Support"],
+          summary: "Long Term Issues the master and slave  details move  for Support",
+          params: {
+            type: "object",
+            properties: {
+              supportId: { type: "string" },
+              customerId: { type: "string" },
+
+            
+            },
+            required: [ "supportId"],
+          },
+        },
+        handler: installationController.getLongTermIssuesByCustomer,
+      });
       fastify.route({
         method: 'POST',
         url: '/api/supportCreateTeamMember/:supportId',