fetch by categories

src/controllers/installationController.js

@@ -6410,10 +6410,9 @@ exports.moveIssueToCategory = async (req, reply) => {
 exports.particularCategory = async (req, reply) => {
   try {
     const { supportId, category } = req.params;
-    const { customerId } = req.query; // ✅ from query string
 
-    if (!customerId || !supportId || !category) {
-      return reply.code(400).send({ error: "customerId, supportId, and category are required" });
+    if (!supportId || !category) {
+      return reply.code(400).send({ error: "supportId and category are required" });
     }
 
     const support = await Support.findOne({ supportId }).lean();
@@ -6421,27 +6420,25 @@ exports.particularCategory = async (req, reply) => {
       return reply.code(404).send({ message: "Support record not found" });
     }
 
-    const issues = (support.categorizedIssues || []).filter(
-      issue => issue.category === category
-    );
-
+    const issues = (support.categorizedIssues || []).filter(issue => issue.category === category);
     if (issues.length === 0) {
       return reply.code(404).send({ message: `No issues found for category: ${category}` });
     }
 
     const hardwareIds = issues.map(issue => issue.hardwareId).filter(Boolean);
 
-    const insensors = await Insensors.find({
-      customerId,
-      hardwareId: { $in: hardwareIds },
-      connected_status: "disconnected"
+    // Get all sensors related to the issues (including masters and potential slaves)
+    const allRelatedSensors = await Insensors.find({
+      hardwareId: { $in: hardwareIds }
     }).lean();
 
-    if (!insensors.length) {
-      return reply.code(404).send({ message: "No disconnected devices found for this category." });
+    if (!allRelatedSensors.length) {
+      return reply.code(404).send({ message: "No matching devices found for this category." });
     }
 
     const orderMap = {};
+    const customerId = allRelatedSensors[0]?.customerId;
+    if (customerId) {
       const orders = await Order.find({ customerId }).lean();
       orders.forEach(order => {
         order.master_connections.forEach(conn => {
@@ -6451,30 +6448,32 @@ exports.particularCategory = async (req, reply) => {
           };
         });
       });
+    }
 
     const disconnectedIssues = [];
 
-    for (const master of insensors.filter(i => i.type === "master")) {
+    for (const master of allRelatedSensors.filter(i => i.type === "master")) {
       const slaves = await Insensors.find({
-        customerId,
-        connected_to: master.hardwareId,
-        connected_status: "disconnected"
+        connected_to: master.hardwareId
       }).lean();
 
-      const slaveDetails = slaves.map(slave => {
+      const disconnectedSlaves = slaves.filter(slave => slave.connected_status === "disconnected");
+
+      // If master is disconnected OR any of its slaves are disconnected, include it
+      if (master.connected_status === "disconnected" || disconnectedSlaves.length > 0) {
+        const slaveDetails = disconnectedSlaves.map(slave => {
           const slaveIssue = issues.find(i => i.hardwareId === slave.hardwareId);
           return {
-          hardwareId: slave.tankhardwareId,
+            hardwareId: slave.hardwareId,
             tankName: slave.tankName || "",
             location: slave.tankLocation || "",
             connected_status: slave.connected_status,
             lora_last_disconnect_time: slave.lora_last_disconnect_time || null,
-          team_member_support_lora_last_check_time: slave.team_member_support_lora_last_check_time,
             connected_to: slave.connected_to || "",
             masterName: orderMap[master.hardwareId]?.masterName || "",
             type: "slave",
             typeOfWater: slave.typeOfWater || "",
-          support_lora_last_check_time: slave.support_lora_last_check_time,
+            support_lora_last_check_time: null,
             category,
             assignedTo: slaveIssue?.assignedTo || null
           };
@@ -6489,19 +6488,22 @@ exports.particularCategory = async (req, reply) => {
           type: "master",
           connected_status: master.connected_status,
           gsm_last_disconnect_time: master.gsm_last_disconnect_time || null,
-        team_member_support_gsm_last_check_time: master.team_member_support_gsm_last_check_time,
-        support_gsm_last_check_time: master.support_gsm_last_check_time,
+          support_gsm_last_check_time: null,
           connected_slave_count: slaveDetails.length,
           connected_slaves: slaveDetails,
           category,
           assignedTo: masterIssue?.assignedTo || null
         });
       }
+    }
+
+    if (disconnectedIssues.length === 0) {
+      return reply.code(404).send({ message: "No disconnected devices found for this category." });
+    }
 
     return reply.send({
       status_code: 200,
       supportId,
-      customerId,
       totalMasters: disconnectedIssues.length,
       disconnectedIssues
     });
@@ -6514,6 +6516,7 @@ exports.particularCategory = async (req, reply) => {
 
 
 
+
 // exports.assignCategorizeIssue = async (request, reply) => {
 //   const { supportId } = request.params;
 //   const { support_teamMemberId, startDate, endDate, category, masterHardwareId } = request.body;