Arminta
/
watermanagement-backend-prod
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

changes

Browse Source
master^2
Bhaskar 5 months ago
parent ef9df5556a
commit f08cda8029
1 changed files with 151 additions and 99 deletions
Show Stats Download Patch File Download Diff File

250
src/controllers/installationController.js
Unescape View File

@ -2624,91 +2624,109 @@ exports.raiseATicket = async (req, reply) => {
return reply.code(400).send({ error: "customerId and connected_to are required" }); return reply.code(400).send({ error: "customerId and connected_to are required" });
} }
const sensors = await Insensors.find({ customerId }); const sensors = await Insensors.find({ customerId }).lean();
const orders = await Order.find({ customerId }).lean();
if (!sensors.length) { if (!sensors.length) {
return reply.code(404).send({ message: "No sensors found for this customer." }); return reply.code(404).send({ message: "No sensors found for this customer." });
} }
const masterSensor = sensors.find(s => s.hardwareId?.trim() === connected_to.trim() && s.type === "master"); const masterSensor = sensors.find(s => s.hardwareId?.trim() === connected_to.trim() && s.type === "master");
if (!masterSensor) { if (!masterSensor) {
return reply.code(404).send({ message: "Master hardwareId not found." }); return reply.code(404).send({ message: "Master hardwareId not found." });
} }
const latestMasterRecord = await IotData.findOne({ hardwareId: connected_to }).sort({ date: -1 }).lean(); const orderMap = {};
orders.forEach(order => {
if (!latestMasterRecord) { order.master_connections.forEach(conn => {
return reply.code(404).send({ message: "No IoT data found for this hardwareId." }); orderMap[conn.hardwareId] = {
} masterName: conn.master_name || null,
location: conn.location || null
};
});
});
const indiaTime = moment.tz(latestMasterRecord.date, "Asia/Kolkata"); const latestMasterRecord = await IotData.findOne({ hardwareId: connected_to }).sort({ date: -1 }).lean();
const now = moment.tz("Asia/Kolkata"); const now = moment.tz("Asia/Kolkata");
const diffInMinutesMaster = now.diff(indiaTime, "minutes");
const masterDisconnected = diffInMinutesMaster > 1 ? [{ let masterConnectedStatus = "disconnected";
hardwareId: connected_to, let lastDataTime = "No data";
masterName: masterSensor.tankName || masterSensor.tankName || "Unknown Master", let diffInMinutes = null;
// disconnectedAt: now.format("DD-MM-YYYY HH:mm:ss")
}] : [];
const connectedSlaves = sensors.filter(sensor => if (latestMasterRecord?.date) {
sensor.connected_to?.trim() === connected_to.trim() && const indiaTime = moment.tz(latestMasterRecord.date, "Asia/Kolkata");
sensor.type === "slave" diffInMinutes = now.diff(indiaTime, "minutes");
lastDataTime = indiaTime.format("DD-MM-YYYY HH:mm:ss");
masterConnectedStatus = diffInMinutes <= 1 ? "connected" : "disconnected";
}
const connectedSlaves = sensors.filter(s =>
s.connected_to?.trim() === connected_to.trim() && s.type === "slave"
); );
const formattedSlaves = [];
const disconnectedSlaves = []; const disconnectedSlaves = [];
for (const slave of connectedSlaves) { for (const slave of connectedSlaves) {
const slaveId = slave.hardwareId?.trim(); const slaveData = latestMasterRecord?.tanks.find(t => t.tankhardwareId === slave.hardwareId);
const matchedTank = latestMasterRecord.tanks.find(tank => tank.tankhardwareId === slaveId); let slaveStatus = "disconnected";
let lastSlaveDataTime = "No data";
if (matchedTank && matchedTank.date) { let slaveDiff = null;
const tankTime = moment.tz(matchedTank.date, "Asia/Kolkata");
const loraDiffInMinutes = now.diff(tankTime, "minutes"); if (slaveData?.date) {
const slaveTime = moment.tz(slaveData.date, "Asia/Kolkata");
slaveDiff = now.diff(slaveTime, "minutes");
lastSlaveDataTime = slaveTime.format("DD-MM-YYYY HH:mm:ss");
slaveStatus = slaveDiff <= 1 ? "connected" : "disconnected";
}
if (loraDiffInMinutes > 1) { if (slaveStatus === "disconnected") {
disconnectedSlaves.push({ disconnectedSlaves.push({
hardwareId: connected_to, slaveHardwareId: slave.hardwareId,
slaveHardwareId: slaveId, slaveName: slave.tankName || "Unknown Slave"
slaveName: slave.tankName || "Unknown Slave" });
});
}
} }
formattedSlaves.push({
hardwareId: slave.hardwareId,
slaveName: slave.tankName || null,
location: slave.tankLocation || null,
type: "slave",
connected_status: slaveStatus,
last_data_time: lastSlaveDataTime,
diff_in_minutes: slaveDiff
});
} }
// Raise tickets if needed
const issuesToAdd = []; const issuesToAdd = [];
if (masterDisconnected.length > 0) { if (masterConnectedStatus === "disconnected") {
const existingGsmIssue = await Support.findOne({ const existing = await Support.findOne({
"issues.hardwareId": connected_to, "issues.hardwareId": connected_to,
"issues.type": "GSM Disconnected" "issues.type": "GSM Disconnected"
}); });
if (!existing) {
if (!existingGsmIssue) {
issuesToAdd.push({ issuesToAdd.push({
type: "GSM Disconnected", type: "GSM Disconnected",
hardwareId: connected_to, hardwareId: connected_to,
message: `Master GSM disconnected - ${connected_to}`, message: `Master GSM disconnected - ${connected_to}`
//disconnectedAt: now.format("DD-MM-YYYY HH:mm:ss")
}); });
} }
} }
// Check for already existing slave issues
const newHardwareIds = []; const newHardwareIds = [];
const newSlaveNames = []; const newSlaveNames = [];
for (const slave of disconnectedSlaves) { for (const s of disconnectedSlaves) {
const existingSlaveIssue = await Support.findOne({ const existing = await Support.findOne({
"issues.hardwareIds": slave.slaveHardwareId, "issues.hardwareIds": s.slaveHardwareId,
"issues.masterHardwareId": connected_to, "issues.masterHardwareId": connected_to,
"issues.type": "LoRa Disconnected" "issues.type": "LoRa Disconnected"
}); });
if (!existing) {
if (!existingSlaveIssue) { newHardwareIds.push(s.slaveHardwareId);
newHardwareIds.push(slave.slaveHardwareId); newSlaveNames.push(s.slaveName);
newSlaveNames.push(slave.slaveName);
} }
} }
@ -2718,14 +2736,12 @@ exports.raiseATicket = async (req, reply) => {
masterHardwareId: connected_to, masterHardwareId: connected_to,
hardwareIds: newHardwareIds, hardwareIds: newHardwareIds,
slaveNames: newSlaveNames, slaveNames: newSlaveNames,
message: `Slaves LoRa disconnected under master ${connected_to}`, message: `Slaves LoRa disconnected under master ${connected_to}`
// disconnectedAt: now.format("DD-MM-YYYY HH:mm:ss")
}); });
} }
if (issuesToAdd.length > 0) { if (issuesToAdd.length > 0) {
const supportRecord = await Support.findOne({ supportId: "AWHYSU64" }); const supportRecord = await Support.findOne({ supportId: "AWHYSU64" });
if (supportRecord) { if (supportRecord) {
await Support.findOneAndUpdate( await Support.findOneAndUpdate(
{ _id: supportRecord._id }, { _id: supportRecord._id },
@ -2734,27 +2750,34 @@ exports.raiseATicket = async (req, reply) => {
issues: { $each: issuesToAdd } issues: { $each: issuesToAdd }
}, },
updatedAt: new Date() updatedAt: new Date()
}, }
{ new: true }
); );
} else {
console.error("Support record not found for supportId AWHYSU64");
} }
} }
const masterDetails = {
hardwareId: connected_to,
masterName: masterSensor.masterName || orderMap[connected_to]?.masterName || null,
location: masterSensor.location || orderMap[connected_to]?.location || null,
type: "master",
connected_status: masterConnectedStatus,
last_data_time: lastDataTime,
diff_in_minutes: diffInMinutes
};
return reply.send({ return reply.send({
status_code: 200, status_code: 200,
message: "Checked connection and updated support if needed.", message: "Checked connection and updated support if needed.",
masterDisconnected, master: masterDetails,
disconnectedSlaves connected_slaves: formattedSlaves
}); });
} catch (error) { } catch (error) {
console.error("Error raising ticket:", error); console.error("Error raising ticket:", error);
return reply.code(500).send({ error: "Internal server error" }); return reply.code(500).send({ error: "Internal server error" });
} }
}; };
// exports.raiseATicket = async (req, reply) => { // exports.raiseATicket = async (req, reply) => {
// try { // try {
// const { customerId, connected_to } = req.params; // const { customerId, connected_to } = req.params;
@ -3161,7 +3184,7 @@ exports.getDisconnectedIssuesBySupportId = async (req, reply) => {
const allIssues = supportRecord.issues || []; const allIssues = supportRecord.issues || [];
const hardwareSet = new Set(); const hardwareSet = new Set();
// Collect all hardware IDs mentioned in issues // Collect all hardware IDs from issues
for (const issue of allIssues) { for (const issue of allIssues) {
if (issue.hardwareId) hardwareSet.add(issue.hardwareId); // GSM if (issue.hardwareId) hardwareSet.add(issue.hardwareId); // GSM
if (Array.isArray(issue.hardwareIds)) { if (Array.isArray(issue.hardwareIds)) {
@ -3181,14 +3204,14 @@ exports.getDisconnectedIssuesBySupportId = async (req, reply) => {
const masterMap = {}; const masterMap = {};
// First, add relevant masters from issues
for (const issue of allIssues) { for (const issue of allIssues) {
// GSM Disconnected
if (issue.type === "GSM Disconnected" && issue.hardwareId) { if (issue.type === "GSM Disconnected" && issue.hardwareId) {
const sensor = sensorMap[issue.hardwareId]; const sensor = sensorMap[issue.hardwareId];
if (sensor && sensor.type === "master") { if (sensor && sensor.type === "master") {
masterMap[sensor.hardwareId] = { masterMap[sensor.hardwareId] = {
hardwareId: sensor.hardwareId, hardwareId: sensor.hardwareId,
masterName: sensor.masterName, masterName: sensor.masterName || null,
location: sensor.location || "", location: sensor.location || "",
type: "master", type: "master",
connected_status: sensor.connected_status, connected_status: sensor.connected_status,
@ -3205,51 +3228,79 @@ exports.getDisconnectedIssuesBySupportId = async (req, reply) => {
} }
} }
// LoRa Disconnected
if (issue.type === "LoRa Disconnected" && issue.masterHardwareId) { if (issue.type === "LoRa Disconnected" && issue.masterHardwareId) {
const masterSensor = sensorMap[issue.masterHardwareId]; const masterSensor = sensorMap[issue.masterHardwareId];
if (masterSensor && masterSensor.type === "master") { if (!masterSensor || masterSensor.type !== "master") continue;
if (!masterMap[masterSensor.hardwareId]) {
masterMap[masterSensor.hardwareId] = {
hardwareId: masterSensor.hardwareId,
masterName: masterSensor.masterName,
location: masterSensor.location || "",
type: "master",
connected_status: masterSensor.connected_status,
gsm_last_check_time: masterSensor.gsm_last_check_time,
gsm_last_disconnect_time: masterSensor.gsm_last_disconnect_time,
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,
support_lora_last_check_time: masterSensor.support_lora_last_check_time,
connected_slave_count: 0,
connected_slaves: []
};
}
const master = masterMap[issue.masterHardwareId]; if (!masterMap[masterSensor.hardwareId]) {
if (master && Array.isArray(issue.hardwareIds)) { masterMap[masterSensor.hardwareId] = {
for (const slaveId of issue.hardwareIds) { hardwareId: masterSensor.hardwareId,
const slaveSensor = sensorMap[slaveId]; masterName: masterSensor.masterName || null,
if (slaveSensor && slaveSensor.type === "slave") { location: masterSensor.location || "",
master.connected_slaves.push({ type: "master",
hardwareId: slaveSensor.hardwareId, connected_status: masterSensor.connected_status,
tankName: slaveSensor.tankName || "", gsm_last_check_time: masterSensor.gsm_last_check_time,
location: slaveSensor.location || "", gsm_last_disconnect_time: masterSensor.gsm_last_disconnect_time,
connected_status: slaveSensor.connected_status, connected_gsm_date: masterSensor.connected_gsm_date,
connected_lora_time: slaveSensor.connected_lora_time, connected_gsm_time: masterSensor.connected_gsm_time,
connected_lora_date: slaveSensor.connected_lora_date, connected_lora_date: masterSensor.connected_lora_date,
lora_last_check_time: slaveSensor.lora_last_check_time, connected_lora_time: masterSensor.connected_lora_time,
lora_last_disconnect_time: slaveSensor.lora_last_disconnect_time, support_lora_last_check_time: masterSensor.support_lora_last_check_time,
connected_to: slaveSensor.connected_to, connected_slave_count: 0,
masterName: master.masterName, connected_slaves: []
type: "slave", };
typeOfWater: slaveSensor.typeOfWater, }
tankHeight: slaveSensor.tankHeight,
support_lora_last_check_time: slaveSensor.support_lora_last_check_time, const master = masterMap[masterSensor.hardwareId];
});
master.connected_slave_count++; // First try from issue.hardwareIds
} let slaveIds = Array.isArray(issue.hardwareIds) ? issue.hardwareIds : [];
// If empty, fallback to slaves connected to this master
if (slaveIds.length === 0) {
const fallbackSlaves = await Insensors.find({ connected_to: masterSensor.hardwareId, type: "slave" }).lean();
for (const slaveSensor of fallbackSlaves) {
master.connected_slaves.push({
hardwareId: slaveSensor.hardwareId,
tankName: slaveSensor.tankName || "",
location: slaveSensor.location || "",
connected_status: slaveSensor.connected_status,
connected_lora_time: slaveSensor.connected_lora_time,
connected_lora_date: slaveSensor.connected_lora_date,
lora_last_check_time: slaveSensor.lora_last_check_time,
lora_last_disconnect_time: slaveSensor.lora_last_disconnect_time,
connected_to: slaveSensor.connected_to,
masterName: master.masterName,
type: "slave",
typeOfWater: slaveSensor.typeOfWater,
tankHeight: slaveSensor.tankHeight,
support_lora_last_check_time: slaveSensor.support_lora_last_check_time,
});
master.connected_slave_count++;
}
} else {
// Populate slaves based on provided hardwareIds
for (const slaveId of slaveIds) {
const slaveSensor = sensorMap[slaveId];
if (slaveSensor && slaveSensor.type === "slave") {
master.connected_slaves.push({
hardwareId: slaveSensor.hardwareId,
tankName: slaveSensor.tankName || "",
location: slaveSensor.location || "",
connected_status: slaveSensor.connected_status,
connected_lora_time: slaveSensor.connected_lora_time,
connected_lora_date: slaveSensor.connected_lora_date,
lora_last_check_time: slaveSensor.lora_last_check_time,
lora_last_disconnect_time: slaveSensor.lora_last_disconnect_time,
connected_to: slaveSensor.connected_to,
masterName: master.masterName,
type: "slave",
typeOfWater: slaveSensor.typeOfWater,
tankHeight: slaveSensor.tankHeight,
support_lora_last_check_time: slaveSensor.support_lora_last_check_time,
});
master.connected_slave_count++;
} }
} }
} }
@ -3271,6 +3322,7 @@ exports.getDisconnectedIssuesBySupportId = async (req, reply) => {
} }
}; };
exports.getDisconnectedCustomerDetails = async (req, reply) => { exports.getDisconnectedCustomerDetails = async (req, reply) => {
try { try {
const { supportId } = req.params; const { supportId } = req.params;

Write Preview
Loading…
Cancel
Save