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

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