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

Merge branch 'master' of http://35.207.205.18:3000/Arminta/watermanagement-backend

Browse Source
master^2
ashok 1 year ago
parent 4e5043597a c25794c75e
commit b97fe18321
1 changed files with 130 additions and 85 deletions
Show Stats Download Patch File Download Diff File

215
src/controllers/createConnectionController.js
Unescape View File

@ -507,94 +507,139 @@ const fastify = require("fastify")({
exports.createConnections = async (req, body) => { exports.createConnections = async (req, res) => {
try { try {
const customerId = req.params.customerId; const customerId = req.params.customerId;
const tankname = req.body.tankname; const tankname = req.body.tankname;
const usertobeInserted = req.body;
const tankInfo = await Tank.findOne({ customerId: customerId.toString(), tankName: tankname });
const usertobeInserted = req.body;
tankInfo.connections.source = tankInfo.tankName; // Find the current tank
const tankInfo = await Tank.findOne({
if (usertobeInserted.inputConnections) { customerId: customerId.toString(),
tankInfo.connections.inputConnections = usertobeInserted.inputConnections.map(connection => { tankName: tankname,
return { });
inputConnections: connection.inputConnections,
input_type: connection.input_type, if (!tankInfo) throw new Error(`Tank ${tankname} not found`);
motor_id: connection.motor_id || null,
motor_status: connection.motor_status || "0", // Update source of connections
motor_stop_status: connection.motor_stop_status || "1", tankInfo.connections.source = tankInfo.tankName;
inputismotor: connection.hasOwnProperty("inputismotor") ? connection.inputismotor : false,
capacity: connection.capacity || null, // Map inputConnections if provided
water_level: connection.water_level || null if (usertobeInserted.inputConnections) {
}; tankInfo.connections.inputConnections = usertobeInserted.inputConnections.map(
}); (connection) => ({
} inputConnections: connection.inputConnections,
input_type: connection.input_type,
if (usertobeInserted.outputConnections) { motor_id: connection.motor_id || null,
tankInfo.connections.outputConnections = usertobeInserted.outputConnections.map(connection => { motor_status: connection.motor_status || "0",
return { motor_stop_status: connection.motor_stop_status || "1",
outputConnections: connection.outputConnections, inputismotor: connection.hasOwnProperty("inputismotor")
output_type: connection.output_type, ? connection.inputismotor
motor_id: connection.motor_id || null, : false,
motor_status: connection.motor_status || "0", capacity: connection.capacity || null,
motor_stop_status: connection.motor_stop_status || "1", water_level: connection.water_level || null,
outputismotor: connection.hasOwnProperty("outputismotor") ? connection.outputismotor : false, })
capacity: connection.capacity || null, );
water_level: connection.water_level || null }
};
}); // Map outputConnections if provided
} if (usertobeInserted.outputConnections) {
tankInfo.connections.outputConnections = usertobeInserted.outputConnections.map(
const tank_connections = await tankInfo.save(); (connection) => ({
outputConnections: connection.outputConnections,
const connection_data_check = tank_connections.connections.inputConnections; output_type: connection.output_type,
const sump_names = connection_data_check.map(d => d.inputConnections); motor_id: connection.motor_id || null,
console.log(sump_names); motor_status: connection.motor_status || "0",
motor_stop_status: connection.motor_stop_status || "1",
const connection_data = usertobeInserted.outputConnections; outputismotor: connection.hasOwnProperty("outputismotor")
console.log(connection_data, "connection_data"); ? connection.outputismotor
for (const data of connection_data) { : false,
if (data['output_type'] === "overhead") { capacity: connection.capacity || null,
const tankName = data['outputConnections']; water_level: connection.water_level || null,
})
if (sump_names.includes(tankname)) { );
console.log(`${tankname} exists in ${sump_names}`); }
} else {
console.log(tankInfo,"areyyy") // Save the updated tank
const tankConnections = await Tank.findOneAndUpdate( const tankConnections = await tankInfo.save();
{ customerId: customerId.toString(), tankName: tankName },
{ // Handle input-to-output and output-to-input logic
$addToSet: { const { inputConnections = [], outputConnections = [] } = usertobeInserted;
'connections.inputConnections': {
$each: [{ // Process inputConnections
inputConnections: tankname, for (const input of inputConnections) {
input_type: 'sump', const relatedTankName = input.inputConnections;
inputismotor: data.outputismotor || false,
motor_id: data.motor_id || null, // Ensure the related tank exists
water_level: tankInfo.waterlevel || null, const relatedTank = await Tank.findOne({
capacity: tankInfo.capacity || null, customerId: customerId.toString(),
motor_status: data.motor_status || "0", tankName: relatedTankName,
motor_stop_status: data.motor_stop_status || "1" });
}], },
// 'connections.outputConnections': { if (relatedTank) {
// $each: [{ outputConnections: tankname, output_type: 'overhead'}], // Check if the current tank already exists in the related tank's outputConnections
// }, const existsInOutput = relatedTank.connections.outputConnections.some(
}, (conn) => conn.outputConnections === tankname
}, );
{ new: true }
); if (!existsInOutput) {
console.log("tankConnections", tankConnections.connections.inputConnections); relatedTank.connections.outputConnections.push({
console.log("tankConnections", tankConnections.connections.outputConnections); outputConnections: tankname,
} output_type: "sump",
} motor_id: input.motor_id || null,
} motor_status: input.motor_status || "0",
motor_stop_status: input.motor_stop_status || "1",
return tank_connections; outputismotor: input.inputismotor || false,
capacity: tankInfo.capacity || null,
water_level: tankInfo.waterlevel || null,
});
await relatedTank.save();
}
}
}
// Process outputConnections
for (const output of outputConnections) {
const relatedTankName = output.outputConnections;
// Ensure the related tank exists
const relatedTank = await Tank.findOne({
customerId: customerId.toString(),
tankName: relatedTankName,
});
if (relatedTank) {
// Check if the current tank already exists in the related tank's inputConnections
const existsInInput = relatedTank.connections.inputConnections.some(
(conn) => conn.inputConnections === tankname
);
if (!existsInInput) {
relatedTank.connections.inputConnections.push({
inputConnections: tankname,
input_type: "overhead",
motor_id: output.motor_id || null,
motor_status: output.motor_status || "0",
motor_stop_status: output.motor_stop_status || "1",
inputismotor: output.outputismotor || false,
capacity: tankInfo.capacity || null,
water_level: tankInfo.waterlevel || null,
});
await relatedTank.save();
}
}
}
return res.send({ success: true, data: tankConnections });
} catch (err) { } catch (err) {
throw boom.boomify(err); console.error(err);
throw boom.boomify(err);
} }
}; };

Write Preview
Loading…
Cancel
Save