From 13bff31a0aa983fb0952a77c03bcb48cef8ee812 Mon Sep 17 00:00:00 2001
From: Bhaskar <bhaskarakishore@armintasolutions.com>
Date: Tue, 20 May 2025 19:08:02 +0530
Subject: [PATCH] changes

---
 src/controllers/installationController.js | 134 ++++++++++++++++++----
 1 file changed, 113 insertions(+), 21 deletions(-)

diff --git a/src/controllers/installationController.js b/src/controllers/installationController.js
index 6d7ecf9c..52f44cdd 100644
--- a/src/controllers/installationController.js
+++ b/src/controllers/installationController.js
@@ -4278,29 +4278,121 @@ exports.assignCategorizeIssue = async (request, reply) => {
 
 
 
-exports.getCategorizedIssue =  async (request, reply) => {
-  const { support_teamMemberId } = request.params;
-
-
-  const supports = await Support.aggregate([
-    { $unwind: '$categorizedIssues' },
-    { $match: { 'categorizedIssues.assignedTo.support_teamMemberId': support_teamMemberId } },
-    { 
-      $group: {
-        _id: '$_id',
-        supportId: { $first: '$supportId' },
-        categorizedIssues: { $push: '$categorizedIssues' }
+
+exports.getCategorizedIssue = async (request, reply) => {
+  try {
+    const { support_teamMemberId } = request.params;
+
+    if (!support_teamMemberId) {
+      return reply.code(400).send({ error: "support_teamMemberId is required" });
+    }
+
+    const supportRecords = await Support.find({
+      'categorizedIssues.assignedTo.support_teamMemberId': support_teamMemberId
+    }).lean();
+
+    if (!supportRecords.length) {
+      return reply.code(404).send({ message: 'No categorized issues assigned to this team member.' });
+    }
+
+    const allIssues = supportRecords.flatMap(s =>
+      s.categorizedIssues
+        .filter(i => i.assignedTo?.support_teamMemberId === support_teamMemberId)
+        .map(i => ({ ...i, supportId: s.supportId }))
+    );
+
+    const supportId = allIssues[0].supportId;
+    const hardwareIds = allIssues.map(issue => issue.hardwareId).filter(Boolean);
+    const masterHardwareIds = allIssues.map(issue => issue.masterHardwareId).filter(Boolean);
+
+    const insensors = await Insensors.find({
+      $or: [
+        { hardwareId: { $in: hardwareIds } },
+        { hardwareId: { $in: masterHardwareIds } }
+      ],
+      connected_status: "disconnected"
+    }).lean();
+
+    if (!insensors.length) {
+      return reply.code(404).send({ message: "No disconnected devices found for this team member." });
+    }
+
+    const customerId = insensors[0]?.customerId || null;
+    const orders = customerId ? await Order.find({ customerId }).lean() : [];
+
+    const orderMap = {};
+    orders.forEach(order => {
+      order.master_connections?.forEach(conn => {
+        orderMap[conn.hardwareId] = {
+          masterName: conn.master_name || null,
+          location: conn.location || null
+        };
+      });
+    });
+
+    const disconnectedIssues = [];
+
+    const masters = insensors.filter(d => d.type === "master");
+
+    for (const master of masters) {
+      const masterIssue = allIssues.find(i => i.masterHardwareId === master.hardwareId);
+      if (!masterIssue) continue;
+
+      const slaves = await Insensors.find({
+        connected_to: master.hardwareId,
+        connected_status: "disconnected",
+        type: "slave"
+      }).lean();
+
+      const slaveDetails = [];
+
+      for (const slave of slaves) {
+        const issue = allIssues.find(i =>
+          i.hardwareId === slave.hardwareId ||
+          (Array.isArray(i.hardwareIds) && i.hardwareIds.includes(slave.hardwareId))
+        );
+
+        slaveDetails.push({
+          hardwareId: slave.hardwareId,
+          tankName: slave.tankName || "",
+          location: slave.location || "",
+          connected_status: slave.connected_status,
+          lora_last_disconnect_time: slave.lora_last_disconnect_time
+            ? moment(slave.lora_last_disconnect_time).format("DD-MM-YYYY HH:mm:ss")
+            : null,
+          connected_to: slave.connected_to || "",
+          masterName: orderMap[master.hardwareId]?.masterName || "",
+          type: "slave",
+          typeOfWater: "",
+          support_lora_last_check_time: null,
+          category: issue?.category || ""
+        });
       }
+
+      disconnectedIssues.push({
+        hardwareId: master.hardwareId,
+        masterName: orderMap[master.hardwareId]?.masterName || "",
+        location: orderMap[master.hardwareId]?.location || "",
+        type: "master",
+        connected_status: master.connected_status,
+        gsm_last_disconnect_time: master.gsm_last_disconnect_time
+          ? moment(master.gsm_last_disconnect_time).format("DD-MM-YYYY HH:mm:ss")
+          : null,
+        support_gsm_last_check_time: null,
+        connected_slave_count: slaveDetails.length,
+        connected_slaves: slaveDetails,
+        category: masterIssue?.category || ""
+      });
     }
-  ]);
 
-  if (supports.length === 0) {
-    return reply.code(404).send({ message: 'No categorized issues assigned to this team member.' });
+    return reply.send({
+      status_code: 200,
+      supportId,
+      totalMasters: disconnectedIssues.length,
+      disconnectedIssues
+    });
+  } catch (error) {
+    console.error("Error in getCategorizedIssue:", error);
+    return reply.code(500).send({ error: "Internal server error" });
   }
-
- 
-  return reply.send({
-    supportId: supports[0].supportId,
-    categorizedIssues: supports[0].categorizedIssues
-  });
 };