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

create connection changes

Browse Source
master
Varun 11 months ago
parent 4155a8423d
commit c13807640b
1 changed files with 129 additions and 85 deletions
Show Stats Download Patch File Download Diff File

214
src/controllers/createConnectionController.js
Unescape View File

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