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

209
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;
if (usertobeInserted.inputConnections) {
tankInfo.connections.inputConnections = usertobeInserted.inputConnections.map(connection => {
return {
inputConnections: connection.inputConnections,
input_type: connection.input_type,
motor_id: connection.motor_id || null,
motor_status: connection.motor_status || "0",
motor_stop_status: connection.motor_stop_status || "1",
inputismotor: connection.hasOwnProperty("inputismotor") ? connection.inputismotor : false,
capacity: connection.capacity || null,
water_level: connection.water_level || null
};
});
}
if (usertobeInserted.outputConnections) {
tankInfo.connections.outputConnections = usertobeInserted.outputConnections.map(connection => {
return {
outputConnections: connection.outputConnections,
output_type: connection.output_type,
motor_id: connection.motor_id || null,
motor_status: connection.motor_status || "0",
motor_stop_status: connection.motor_stop_status || "1",
outputismotor: connection.hasOwnProperty("outputismotor") ? connection.outputismotor : false,
capacity: connection.capacity || null,
water_level: connection.water_level || null
};
});
}
const tank_connections = await tankInfo.save(); // Find the current tank
const tankInfo = await Tank.findOne({
const connection_data_check = tank_connections.connections.inputConnections; customerId: customerId.toString(),
const sump_names = connection_data_check.map(d => d.inputConnections); tankName: tankname,
console.log(sump_names); });
const connection_data = usertobeInserted.outputConnections; if (!tankInfo) throw new Error(`Tank ${tankname} not found`);
console.log(connection_data, "connection_data");
for (const data of connection_data) { // Update source of connections
if (data['output_type'] === "overhead") { tankInfo.connections.source = tankInfo.tankName;
const tankName = data['outputConnections'];
// Map inputConnections if provided
if (sump_names.includes(tankname)) { if (usertobeInserted.inputConnections) {
console.log(`${tankname} exists in ${sump_names}`); tankInfo.connections.inputConnections = usertobeInserted.inputConnections.map(
} else { (connection) => ({
console.log(tankInfo,"areyyy") inputConnections: connection.inputConnections,
const tankConnections = await Tank.findOneAndUpdate( input_type: connection.input_type,
{ customerId: customerId.toString(), tankName: tankName }, motor_id: connection.motor_id || null,
{ motor_status: connection.motor_status || "0",
$addToSet: { motor_stop_status: connection.motor_stop_status || "1",
'connections.inputConnections': { inputismotor: connection.hasOwnProperty("inputismotor")
$each: [{ ? connection.inputismotor
inputConnections: tankname, : false,
input_type: 'sump', capacity: connection.capacity || null,
inputismotor: data.outputismotor || false, water_level: connection.water_level || null,
motor_id: data.motor_id || null, })
water_level: tankInfo.waterlevel || null, );
capacity: tankInfo.capacity || null, }
motor_status: data.motor_status || "0",
motor_stop_status: data.motor_stop_status || "1" // Map outputConnections if provided
}], }, if (usertobeInserted.outputConnections) {
// 'connections.outputConnections': { tankInfo.connections.outputConnections = usertobeInserted.outputConnections.map(
// $each: [{ outputConnections: tankname, output_type: 'overhead'}], (connection) => ({
// }, outputConnections: connection.outputConnections,
}, output_type: connection.output_type,
}, motor_id: connection.motor_id || null,
{ new: true } motor_status: connection.motor_status || "0",
); motor_stop_status: connection.motor_stop_status || "1",
console.log("tankConnections", tankConnections.connections.inputConnections); outputismotor: connection.hasOwnProperty("outputismotor")
console.log("tankConnections", tankConnections.connections.outputConnections); ? connection.outputismotor
} : false,
} capacity: connection.capacity || null,
} water_level: connection.water_level || null,
})
);
}
// Save the updated tank
const tankConnections = await tankInfo.save();
return tank_connections; // Handle input-to-output and output-to-input logic
const { inputConnections = [], outputConnections = [] } = usertobeInserted;
// Process inputConnections
for (const input of inputConnections) {
const relatedTankName = input.inputConnections;
// 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 outputConnections
const existsInOutput = relatedTank.connections.outputConnections.some(
(conn) => conn.outputConnections === tankname
);
if (!existsInOutput) {
relatedTank.connections.outputConnections.push({
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",
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