You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
762 lines
27 KiB
762 lines
27 KiB
//const Tank = require("../models/tanks");
|
|
const { Tank, MotorData, IotData } = require('../models/tanks')
|
|
|
|
const User = require("../models/User");
|
|
const boom = require("boom");
|
|
const fastify = require("fastify")({
|
|
logger: true,
|
|
});
|
|
// const tanksController = require("./tanksController")
|
|
|
|
const moment = require('moment');
|
|
|
|
|
|
exports.addTanks = async (req, reply) => {
|
|
try {
|
|
|
|
var customerId = req.params.customerId
|
|
//const username = req.params.username;
|
|
|
|
console.log(req.params);
|
|
//const {username} = loginObject.user.username;
|
|
//console.log(loginObject.user.username)
|
|
// const userInfo = await User.findOne({ username: username.toString() });
|
|
// const updateData = req.body;
|
|
|
|
|
|
|
|
// console.log("This is the reply in the handler after the validations", reply);
|
|
tankData = {
|
|
customerId: customerId,
|
|
hardwareId: req.body.hardwareId,
|
|
tankName: req.body.tankName,
|
|
blockName: req.body.blockName,
|
|
capacity: req.body.capacity,
|
|
typeOfWater: req.body.typeOfWater,
|
|
|
|
tankLocation:req.body.tankLocation.toLowerCase(),
|
|
|
|
};
|
|
//console.log( req.body.tankLocation.toLowerCase())
|
|
|
|
var tank_name = req.body.tankName
|
|
var tankLocation = req.body.tankLocation.toLowerCase()
|
|
var i_tank = await Tank.findOne({ tankName: tank_name,customerId:customerId,tankLocation:tankLocation})
|
|
if(i_tank){
|
|
throw new Error('tankname already exists');
|
|
}
|
|
else {
|
|
|
|
var tank = new Tank(tankData);
|
|
|
|
checkFormEncoding = isUserFormUrlEncoded(req);
|
|
if (checkFormEncoding.isUserFormUrlEncoded) {
|
|
usertobeInserted = checkFormEncoding.tank;
|
|
console.log("thsi true url string");
|
|
tank.customerId = usertobeInserted.customerId
|
|
tank.hardwareId = usertobeInserted.hardwareId;
|
|
tank.tankName = usertobeInserted.tankName;
|
|
tank.blockName = usertobeInserted.blockName;
|
|
tank.capacity = usertobeInserted.capacity;
|
|
tank.typeOfWater = usertobeInserted.typeOfWater;
|
|
|
|
tank.tankLocation = (usertobeInserted.tankLocation).toLowerCase();
|
|
console.log((usertobeInserted.tankLocation).toLowerCase())
|
|
}
|
|
}
|
|
const insertedTank = await tank.save();
|
|
|
|
return insertedTank;
|
|
|
|
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
|
|
//update selected tank
|
|
exports.updateTanksInfo = async (req, reply) => {
|
|
|
|
try {
|
|
var customerId = req.params.customerId;
|
|
var tankName = req.query.tankName;
|
|
const tank = req.body;
|
|
const { ...updateData } = tank;
|
|
const update = await Tank.findOneAndUpdate({ tankName: tankName,customerId:customerId, }, updateData, { new: true });
|
|
console.log(update.username)
|
|
//return update;
|
|
|
|
reply.send({ status_code: 200, data: update });
|
|
|
|
|
|
|
|
}
|
|
catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
//delete selected tank
|
|
exports.deleteTanksInfo = async (req, reply) => {
|
|
try {
|
|
const customerId = req.params.customerId;
|
|
const tankName = req.query.tankName;
|
|
const tankLocation = req.body.tankLocation.toLowerCase();
|
|
const tank = await Tank.findOneAndDelete({ tankName: tankName,customerId:customerId,tankLocation:tankLocation });
|
|
|
|
reply.send({ status_code: 200, data: tank});
|
|
// return tank;
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
//get tanks data by passing username
|
|
exports.getTank = async (req, reply) => {
|
|
try {
|
|
await Tank.find({customerId: req.query.customerId})
|
|
.exec()
|
|
.then((docs) => {
|
|
reply.send({ status_code: 200, data: docs, count: docs.length });
|
|
})
|
|
.catch((err) => {
|
|
console.log(err);
|
|
reply.send({ error: err });
|
|
});
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
|
|
//exports.getTanklevels = async (req, reply) => {
|
|
// try {
|
|
// const customerId = req.params.customerId;
|
|
// const tankName = req.query.tankName;
|
|
|
|
// setInterval(async function () {
|
|
// const randomNumber = Math.floor(Math.random() * (5500 - 1000) + 1000);
|
|
// console.log(randomNumber)
|
|
// console.log( await Tank.findOneAndUpdate({ customerId: customerId, tankName: tankName }, { $set: { waterlevel: randomNumber } }));
|
|
// }, 2000);
|
|
|
|
// return { message: 'Water level will be updated every 2 seconds' };
|
|
//}
|
|
|
|
// catch (err) {
|
|
// throw boom.boomify(err);
|
|
// }
|
|
//};
|
|
|
|
exports.updateTanklevels = async (req, reply) => {
|
|
try {
|
|
const customerId = req.params.customerId;
|
|
const tanks = await Tank.find({ customerId });
|
|
|
|
const intervals = {};
|
|
|
|
for (const tank of tanks) {
|
|
const tankId = tank._id;
|
|
const tank_name = tank.tankName
|
|
let capacity = parseInt(tank.capacity.replace(/,/g, ''), 10);
|
|
let waterLevel = parseInt(tank.waterlevel.replace(/,/g, ''), 10);
|
|
|
|
const intervalId = setInterval(async function () {
|
|
const newWaterLevel = Math.floor(waterLevel - 200);
|
|
|
|
if (newWaterLevel <= 0) {
|
|
clearInterval(intervals[tankId]);
|
|
console.log(`Stopped updating tank with ID ${tankId}`);
|
|
return;
|
|
}
|
|
else{
|
|
const result = await Tank.findOneAndUpdate(
|
|
{ _id: tankId },
|
|
{ $set: { waterlevel: newWaterLevel } }
|
|
);
|
|
console.log(tank_name+"="+newWaterLevel)
|
|
}
|
|
|
|
// console.log(result);
|
|
|
|
|
|
|
|
waterLevel = newWaterLevel;
|
|
}, 2000);
|
|
|
|
intervals[tankId] = intervalId;
|
|
}
|
|
|
|
return { message: 'Water level updates started' };
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
exports.getTanklevels = async (req, reply) => {
|
|
try {
|
|
const customerId = req.params.customerId;
|
|
|
|
const updated_data = await Tank.find({ customerId: customerId });
|
|
|
|
let sumSumpDrinkingWater = 0;
|
|
let sumOverheadDrinkingWater = 0;
|
|
|
|
updated_data.forEach((tank) => {
|
|
if (tank.tankLocation === 'sump' && tank.typeOfWater === 'Drinking Water') {
|
|
sumSumpDrinkingWater += parseInt(tank.waterlevel);
|
|
} else if (tank.tankLocation === 'overhead' && tank.typeOfWater === 'Drinking Water') {
|
|
sumOverheadDrinkingWater += parseInt(tank.waterlevel);
|
|
}
|
|
});
|
|
|
|
reply.send({
|
|
status_code: 200,
|
|
data: updated_data,
|
|
totalDrinkingWaterInSump: sumSumpDrinkingWater,
|
|
totalDrinkingWaterInOverhead: sumOverheadDrinkingWater
|
|
});
|
|
|
|
return { message: 'success' };
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
|
|
exports.motorAction = async (req, reply) => {
|
|
try {
|
|
//let start_time,stop_time
|
|
const customerId = req.params.customerId;
|
|
const action = req.body.action
|
|
const receiver_tank = req.body.to
|
|
const receiver_tank_info = await Tank.findOne({ customerId ,tankName:receiver_tank,tankLocation:(req.body.to_type).toLowerCase()});
|
|
const receiver_capacity = parseInt((receiver_tank_info.capacity).replace(/,/g, ''), 10)
|
|
const desired_water_percentage = parseInt((req.body.percentage).replace(/,/g, ''), 10)
|
|
const intervals = {};
|
|
|
|
|
|
if(action === "start"){
|
|
const start_time = new Date().toLocaleString('en-US', {timeZone: 'Asia/Kolkata'})
|
|
|
|
const supplier_tank = req.body.from
|
|
const supplier_tank_type = (req.body.from_type).toLowerCase()
|
|
const receiver_type = (req.body.to_type).toLowerCase()
|
|
console.log(supplier_tank)
|
|
|
|
|
|
if(supplier_tank_type==="sump" && receiver_type === "overhead"){
|
|
await Tank.findOneAndUpdate({customerId, tankName: receiver_tank,tankLocation:receiver_type}, { $set: { motor_status: "1" } });
|
|
|
|
const supplier_tank_info1 = await Tank.findOne({ customerId ,tankName:supplier_tank,tankLocation:supplier_tank_type});
|
|
//console.log(supplier_tank_info1)
|
|
//const initial_update = parseInt(supplier_tank_info1.waterlevel.replace(/,/g, ''), 10)-200;
|
|
// await Tank.findOneAndUpdate({customerId, tankName: supplier_tank,tankLocation:supplier_tank_type}, { $set: { waterlevel: initial_update } });
|
|
const supplier_tank_info = await Tank.findOne({ customerId ,tankName:supplier_tank,tankLocation:supplier_tank_type});
|
|
|
|
// await changingfrom_tankwaterlevel(customerId,initial_update,supplier_tank_info);
|
|
let supplier_waterlevel = parseInt(supplier_tank_info.waterlevel.replace(/,/g, ''), 10)
|
|
// console.log(supplier_waterlevel)
|
|
let receiver_waterlevel = parseInt(receiver_tank_info.waterlevel.replace(/,/g, ''), 10)
|
|
intervals[receiver_tank] = setInterval(async function () {
|
|
// Calculate new water levels
|
|
const supplier_tank_info2 = await Tank.findOne({ customerId ,tankName:supplier_tank,tankLocation:supplier_tank_type});
|
|
const rcvr_info = await Tank.findOne({ customerId ,tankName:receiver_tank,tankLocation:receiver_type});
|
|
const newWaterLevel = receiver_waterlevel + 350//Math.floor(supplier_waterlevel * 0.1);
|
|
const newSupplierWaterLevel = supplier_waterlevel//Math.floor(supplier_waterlevel * 0.1);
|
|
const supplier_capacity = parseInt(supplier_tank_info.capacity.replace(/,/g, ''), 10)
|
|
console.log((newSupplierWaterLevel/supplier_capacity)*100)
|
|
// Check if updating should stop
|
|
if ((newSupplierWaterLevel/supplier_capacity)*100 <= 5 || (newWaterLevel/receiver_capacity)*100 >= 95 || (newWaterLevel/receiver_capacity)*100 >= desired_water_percentage || rcvr_info.motor_status === "0") {
|
|
clearInterval(intervals[receiver_tank]); // Clear the interval for this tank
|
|
delete intervals[receiver_tank];
|
|
await Tank.findOneAndUpdate({customerId, tankName: receiver_tank,tankLocation:receiver_type}, { $set: { motor_status: "0" } });
|
|
|
|
console.log("end for"+receiver_tank);
|
|
} else {
|
|
// Update water levels in database
|
|
//supplier_waterlevel = newSupplierWaterLevel;
|
|
receiver_waterlevel = newWaterLevel;
|
|
console.log((newSupplierWaterLevel/supplier_capacity)*100)
|
|
// console.log((newWaterLevel/receiver_capacity)*100)
|
|
console.log(receiver_tank+""+newWaterLevel+""+"bore to sump")
|
|
await Tank.findOneAndUpdate({customerId, tankName: receiver_tank,tankLocation:receiver_type}, { $set: { waterlevel: newWaterLevel } })
|
|
if (supplier_tank_info2.motor_status==="0"){
|
|
supplier_waterlevel = parseInt(supplier_tank_info2.waterlevel.replace(/,/g, ''), 10)-350
|
|
console.log(supplier_tank+""+newSupplierWaterLevel+""+"s to oh")
|
|
await Tank.findOneAndUpdate({customerId, tankName: supplier_tank,tankLocation:supplier_tank_type}, { $set: { waterlevel: supplier_waterlevel } })
|
|
}
|
|
|
|
}
|
|
}, 2000);
|
|
|
|
}
|
|
|
|
|
|
|
|
// if(supplier_tank_type==="sump" && receiver_type === "overhead"){
|
|
// await Tank.findOneAndUpdate({customerId, tankName: receiver_tank}, { $set: { motor_status: 1 } });
|
|
|
|
// // console.log(rcvr_info.motor_status)
|
|
// const supplier_tank_info1 = await Tank.findOne({ customerId ,tankName:supplier_tank});
|
|
// initial_update = parseInt(supplier_tank_info1.capacity.replace(/,/g, ''), 10)/2;
|
|
|
|
// await Tank.findOneAndUpdate({customerId, tankName: supplier_tank}, { $set: { waterlevel: initial_update } });
|
|
// const supplier_tank_info = await Tank.findOne({ customerId ,tankName:supplier_tank});
|
|
|
|
// let supplier_waterlevel = parseInt(supplier_tank_info.waterlevel.replace(/,/g, ''), 10)
|
|
// let receiver_waterlevel = parseInt(receiver_tank_info.waterlevel.replace(/,/g, ''), 10)
|
|
// intervalId = setInterval(async function () {
|
|
// const rcvr_info = await Tank.findOne({ customerId ,tankName:receiver_tank});
|
|
// const supplier_capacity = parseInt(supplier_tank_info.capacity.replace(/,/g, ''), 10)
|
|
// // Calculate new water levels
|
|
// const newWaterLevel = receiver_waterlevel + 200//Math.floor(supplier_waterlevel * 0.1);
|
|
// const newSupplierWaterLevel = Math.min(supplier_capacity, supplier_waterlevel + 350);// Math.floor(supplier_waterlevel * 0.15));
|
|
// // console.log(newWaterLevel)
|
|
// // console.log(newSupplierWaterLevel)
|
|
// // console.log(rcvr_info.motor_status)
|
|
// // console.log(rcvr_info.tankName)
|
|
|
|
// // Check if updating should stop
|
|
// if ( (newWaterLevel/receiver_capacity)*100 >= 95 || (newWaterLevel/receiver_capacity)*100 >= desired_water_percentage || rcvr_info.motor_status === 0) {
|
|
|
|
// clearInterval(intervalId)
|
|
// await Tank.findOneAndUpdate({customerId, tankName: receiver_tank}, { $set: { motor_status: 0 } });
|
|
|
|
// console.log("end");
|
|
// } else {
|
|
// // Update water levels in database
|
|
// supplier_waterlevel = newSupplierWaterLevel;
|
|
// receiver_waterlevel = newWaterLevel;
|
|
// // console.log((newSupplierWaterLevel/supplier_capacity)*100)
|
|
// // console.log((newWaterLevel/receiver_capacity)*100)
|
|
// await Promise.all([
|
|
// Tank.findOneAndUpdate({customerId, tankName: receiver_tank}, { $set: { waterlevel: newWaterLevel } }),
|
|
// Tank.findOneAndUpdate({customerId, tankName: supplier_tank}, { $set: { waterlevel: newSupplierWaterLevel } })
|
|
// ]);
|
|
// }
|
|
// }, 2000);
|
|
|
|
|
|
// }
|
|
|
|
|
|
if(supplier_tank_type==="bore" && receiver_type === "sump"){
|
|
const receiver_capacity = parseInt(receiver_tank_info.capacity.replace(/,/g, ''), 10)
|
|
// console.log(receiver_capacity,"0",receiver_tank_info.tankName)
|
|
await Tank.findOneAndUpdate({customerId, tankName: receiver_tank,tankLocation:receiver_type}, { $set: { motor_status: "1" } });
|
|
|
|
let receiver_waterlevel = parseInt(receiver_tank_info.waterlevel.replace(/,/g, ''), 10)
|
|
// console.log(receiver_waterlevel,"1")
|
|
intervals[receiver_tank] = setInterval(async function () {
|
|
// Calculate new water levels
|
|
const rcvr_info = await Tank.findOne({ customerId ,tankName:receiver_tank,tankLocation:receiver_type});
|
|
//console.log(rcvr_info)
|
|
//console.log(rcvr_info.motor_status)
|
|
const newWaterLevel = receiver_waterlevel+450;
|
|
//console.log(newWaterLevel,"2",receiver_tank_info.tankName)
|
|
// Check if updating should stop
|
|
if ((newWaterLevel/receiver_capacity)*100 >= 97 || (newWaterLevel/receiver_capacity)*100 >= desired_water_percentage || rcvr_info.motor_status === "0" ) {
|
|
|
|
await Tank.findOneAndUpdate({customerId, tankName: receiver_tank,tankLocation:receiver_type}, { $set: { motor_status: "0" } });
|
|
clearInterval(intervals[receiver_tank]); // Clear the interval for this tank
|
|
delete intervals[receiver_tank];
|
|
console.log("end for" + receiver_tank);
|
|
} else {
|
|
// Update water levels in database
|
|
|
|
receiver_waterlevel = newWaterLevel;
|
|
|
|
//console.log((newWaterLevel/receiver_capacity)*100,"4",receiver_tank_info.tankName)
|
|
await Tank.findOneAndUpdate({customerId, tankName: receiver_tank,tankLocation:receiver_type}, { $set: { waterlevel: newWaterLevel } })
|
|
console.log(receiver_tank+"="+newWaterLevel+"="+"bore to sump")
|
|
}
|
|
}, 2000);
|
|
|
|
}
|
|
// console.log(customerId,req.body.from,req.body.from_type,receiver_tank,req.body.to_type,)
|
|
motorData = {
|
|
|
|
customerId:customerId,
|
|
supplierTank : req.body.from,
|
|
supplier_type: req.body.from_type,
|
|
receiverTank: receiver_tank,
|
|
receiver_type: req.body.to_type,
|
|
startTime: req.body.startTime,
|
|
stopTime: req.body.stopTime,
|
|
|
|
|
|
|
|
};
|
|
var motorData = new MotorData(motorData);
|
|
|
|
checkFormEncoding = isUserFormUrlEncoded(req);
|
|
if (checkFormEncoding.isUserFormUrlEncoded) {
|
|
usertobeInserted = checkFormEncoding.motorData;
|
|
console.log("thsi true url string");
|
|
motorData.customerId = customerId;
|
|
motorData.supplierTank = req.body.from;
|
|
motorData.receiverTank = receiver_tank;
|
|
motorData.supplier_type = req.body.from_type;
|
|
motorData.receiver_type = req.body.to_type;
|
|
motorData.startTime = usertobeInserted.startTime;
|
|
motorData.stopTime = usertobeInserted.stopTime;
|
|
|
|
|
|
}
|
|
const motor_data = await motorData.save();
|
|
// reply.send({ status_code: 200, data: motor_data });
|
|
|
|
|
|
|
|
|
|
reply.send({ status_code: 200, "start time": start_time, data: motor_data});
|
|
console.log(start_time)
|
|
return motor_data
|
|
|
|
|
|
}
|
|
|
|
else if (action === "stop") {
|
|
const stop_time = new Date().toLocaleString('en-US', {timeZone: 'Asia/Kolkata'})
|
|
// console.log(stop_time)
|
|
// clearInterval(intervalId);
|
|
await Tank.findOneAndUpdate({customerId, tankName: receiver_tank,tankLocation:(req.body.to_type).toLowerCase()}, { $set: { motor_status: "0" } });
|
|
|
|
reply.send({ status_code: 200, "stop time": stop_time});
|
|
} else {
|
|
throw new Error("Invalid action");
|
|
}
|
|
|
|
return { message: 'Water level updates started' };
|
|
|
|
} catch (err) {
|
|
throw new Error(`Failed to start/stop water level updates: ${err.message}`);
|
|
|
|
};
|
|
};
|
|
|
|
|
|
exports.consumption = async (req, reply) => {
|
|
try {
|
|
const customerId = req.params.customerId;
|
|
const tanks = await Tank.find({ customerId });
|
|
const tankData = [];
|
|
for (const tank of tanks) {
|
|
const tankId = tank._id;
|
|
let capacity = parseInt(tank.capacity.replace(/,/g, ''), 10);
|
|
let waterLevel = capacity*2+1700; // initial water level
|
|
const tankname = tank.tankName
|
|
|
|
|
|
const newWaterLevel = Math.floor(waterLevel);
|
|
tankData.push({ tankname, waterLevel: newWaterLevel });
|
|
|
|
|
|
// console.log(newWaterLevel);
|
|
|
|
}
|
|
reply.send({ status_code: 200, tankData });
|
|
|
|
return { message: 'Water level updates started' };
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
exports.calculateCapacity = async (req, reply) => {
|
|
try {
|
|
const shape = req.body.shape
|
|
if(shape==="rectangle"){
|
|
const { length, width, height } = req.body
|
|
|
|
// Ensure all parameters are valid numbers
|
|
if (isNaN(length) || isNaN(width) || isNaN(height)) {
|
|
reply.code(400).send('Invalid input parameters')
|
|
return
|
|
}
|
|
|
|
// Calculate the capacity of the water tank in liters
|
|
const capacity = length * width * height * 1000
|
|
|
|
reply.send({ status_code: 200, capacity: capacity});
|
|
|
|
|
|
return { message: 'success' };
|
|
|
|
}
|
|
if(shape==="cylinder"){
|
|
console.log("hii1")
|
|
const { length,diameter } = req.body
|
|
|
|
// Ensure all parameters are valid numbers
|
|
if (isNaN(length) || isNaN(diameter)) {
|
|
reply.code(400).send('Invalid input parameters')
|
|
return
|
|
}
|
|
|
|
// Calculate the capacity of the water tank in liters
|
|
const radius = diameter / 2
|
|
const volume = Math.PI * Math.pow(radius, 2) * length
|
|
const capacity = volume * 1000
|
|
|
|
reply.send({ status_code: 200, capacity: capacity});
|
|
|
|
|
|
return { message: 'success' };
|
|
|
|
}
|
|
|
|
// if(shape==="oval"){
|
|
// console.log("hii3")
|
|
// const { length, width, height } = req.body
|
|
|
|
// // Ensure all parameters are valid numbers
|
|
// if (isNaN(length) || isNaN(width) || isNaN(height)) {
|
|
// reply.code(400).send('Invalid input parameters')
|
|
// return
|
|
// }
|
|
|
|
// // Calculate the capacity of the water tank in liters
|
|
// const radius = height / 2
|
|
// const a = width - height
|
|
// const area = Math.PI * radius * radius + 2 * radius * a
|
|
// const volume = area * length
|
|
// const capacity = volume * 1000
|
|
|
|
// // Format the result with two decimal places and comma-separated thousands
|
|
// const formattedCapacity = capacity.toFixed(2).replace(/\d(?=(\d{3})+\.)/g, '$&,')
|
|
|
|
// reply.send({ status_code: 200, capacity: formattedCapacity});
|
|
|
|
|
|
// return { message: 'success' };
|
|
|
|
// }
|
|
|
|
|
|
// if(shape==="horizontalellipse"){
|
|
|
|
|
|
// const { length, width, height } = req.body
|
|
|
|
// // Ensure all parameters are valid numbers
|
|
// if (isNaN(length) || isNaN(width) || isNaN(height)) {
|
|
// reply.code(400).send('Invalid input parameters')
|
|
// return
|
|
// }
|
|
|
|
// // Calculate the capacity of the water tank in liters
|
|
// const radius1 = length / 2
|
|
// const radius2 = width / 2
|
|
// const volume = Math.PI * radius1 * radius2 * height
|
|
// const capacity = volume * 1000
|
|
// reply.send({ status_code: 200, capacity: capacity});
|
|
|
|
|
|
// return { message: 'success' };
|
|
|
|
// }
|
|
if(shape==="userdefined"){
|
|
const capacity = req.body
|
|
|
|
reply.send({ status_code: 200, capacity: capacity});
|
|
|
|
|
|
return { message: 'success' };
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
exports.IotDevice = async (req, reply) => {
|
|
try {
|
|
const { hardwareId, tankHeight, maxLevel, minLevel, mode } = req.body;
|
|
|
|
// create a new tank document with the current date and time
|
|
const currentDate = new Date();
|
|
const date = currentDate.toISOString(); // save the date as an ISO string
|
|
const time = currentDate.toLocaleTimeString('en-IN', {hour12:false, timeZone: 'Asia/Kolkata' });
|
|
const tank = new IotData({ hardwareId, tankHeight, maxLevel, minLevel, mode, date, time });
|
|
|
|
// save the document to MongoDB
|
|
await tank.save();
|
|
|
|
// get all the tank documents for the current hardwareId sorted in descending order of date and time
|
|
const tanks = await IotData.find({ hardwareId }).sort({ date: -1, time: -1 });
|
|
|
|
// if the number of documents for the current hardwareId is greater than three, remove the oldest documents until there are only three left
|
|
if (tanks.length > 3) {
|
|
const oldestDocuments = tanks.slice(3);
|
|
for (const doc of oldestDocuments) {
|
|
await IotData.deleteOne({ _id: doc._id });
|
|
}
|
|
}
|
|
|
|
// get the latest three tank documents for the current hardwareId sorted in descending order of date and time
|
|
const latestTanks = await IotData.find({ hardwareId }).sort({ date: -1, time: -1 }).limit(3);
|
|
|
|
// send the latest three documents in descending order of date and time
|
|
reply.code(200).send({ latestTanks: latestTanks.reverse() });
|
|
} catch (err) {
|
|
// send an error response
|
|
reply.code(500).send({ error: err.message });
|
|
}
|
|
};
|
|
|
|
|
|
exports.getIotD = async(req, reply) => {
|
|
try {
|
|
await IotData.find({hardwareId: req.query.hardwareId})
|
|
.exec()
|
|
.then((docs) => {
|
|
reply.send({ status_code: 200, data: docs, count: docs.length });
|
|
})
|
|
.catch((err) => {
|
|
console.log(err);
|
|
reply.send({ error: err });
|
|
});
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
}
|
|
|
|
|
|
exports.getLatestData = async (req, reply) => {
|
|
try {
|
|
const hardwareId = req.params.hardwareId;
|
|
|
|
// get the latest two tank documents for the current hardwareId sorted in descending order of date and time
|
|
const latestTanks = await IotData.find({ hardwareId }).sort({ date: -1, time: -1 }).limit(2);
|
|
|
|
// if the number of documents for the current hardwareId is less than two, return an error response
|
|
if (latestTanks.length < 2) {
|
|
return reply.code(404).send({ error: 'Not enough data' });
|
|
}
|
|
|
|
// calculate the time difference between the latest and previous documents
|
|
const latestDate = new Date(latestTanks[0].date);
|
|
const previousDate = new Date(latestTanks[1].date);
|
|
const latestTime = latestTanks[0].time.split('.')[0]; // remove milliseconds
|
|
const previousTime = latestTanks[1].time.split('.')[0]; // remove milliseconds
|
|
latestDate.setHours(parseInt(latestTime.substring(0, 2)), parseInt(latestTime.substring(3, 5)), parseInt(latestTime.substring(6, 8)));
|
|
previousDate.setHours(parseInt(previousTime.substring(0, 2)), parseInt(previousTime.substring(3, 5)), parseInt(previousTime.substring(6, 8)));
|
|
const timeDiff = (latestDate.getTime() - previousDate.getTime()) / 1000; // convert from milliseconds to seconds
|
|
console.log(latestDate,previousDate,latestTime,previousTime,timeDiff)
|
|
reply.code(200).send({ timeDiff });
|
|
|
|
} catch (err) {
|
|
// send an error response
|
|
reply.code(500).send({ error: err.message });
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
exports.checkStatusofIot = async (req, reply) => {
|
|
try {
|
|
// get a list of unique hardware IDs in the collection
|
|
const hardwareIds = await IotData.distinct('hardwareId');
|
|
|
|
// create an empty object to store the time differences for each hardware ID
|
|
const timeDiffs = {};
|
|
|
|
// loop over each hardware ID and calculate the time difference between the latest two records
|
|
for (const hardwareId of hardwareIds) {
|
|
// get the latest two records for the current hardware ID
|
|
const latestTanks = await IotData.find({ hardwareId }).sort({ date: -1, time: -1 }).limit(2);
|
|
|
|
// if the number of records for the current hardware ID is less than two, skip to the next ID
|
|
if (latestTanks.length < 2) {
|
|
continue;
|
|
}
|
|
|
|
// calculate the time difference between the latest and previous records for the current hardware ID
|
|
const latestDate = new Date(latestTanks[0].date);
|
|
const previousDate = new Date(latestTanks[1].date);
|
|
const latestTime = latestTanks[0].time.split('.')[0]; // remove milliseconds
|
|
const previousTime = latestTanks[1].time.split('.')[0]; // remove milliseconds
|
|
latestDate.setHours(parseInt(latestTime.substring(0, 2)), parseInt(latestTime.substring(3, 5)), parseInt(latestTime.substring(6, 8)));
|
|
previousDate.setHours(parseInt(previousTime.substring(0, 2)), parseInt(previousTime.substring(3, 5)), parseInt(previousTime.substring(6, 8)));
|
|
const timeDiff = (latestDate.getTime() - previousDate.getTime()) / 1000; // convert from milliseconds to seconds
|
|
|
|
// store the time difference for the current hardware ID
|
|
timeDiffs[hardwareId] = timeDiff;
|
|
}
|
|
|
|
// send the time differences for all hardware IDs
|
|
reply.code(200).send({ timeDiffs });
|
|
|
|
} catch (err) {
|
|
// send an error response
|
|
reply.code(500).send({ error: err.message });
|
|
}
|
|
};
|
|
|
|
exports.totalwaterLevelSum = async (request, reply) => {
|
|
const { tankLocation, typeOfWater } = request.query;
|
|
|
|
const waterlevelSum = await Tank.aggregate([
|
|
{
|
|
$match: { tankLocation, typeOfWater }
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null,
|
|
totalWaterlevel: { $sum: { $toInt: '$waterlevel' } }
|
|
}
|
|
}
|
|
]);
|
|
|
|
const result = waterlevelSum[0]?.totalWaterlevel ?? 0;
|
|
|
|
reply.send({ waterlevelSum: result });
|
|
}
|
|
|
|
|
|
|
|
|
|
exports.startUpdateLoop = async (request, reply) => {
|
|
const updateInterval = 5000;
|
|
|
|
setInterval(async () => {
|
|
try {
|
|
const iotTank = await IotData.findOne({ hardwareId: request.body.hardwareId });
|
|
if (!iotTank) {
|
|
console.log(`IOTtank not found for hardwareId ${request.body.hardwareId}`);
|
|
return;
|
|
}
|
|
|
|
const currentWaterlevel = Number(iotTank.tankHeight) * 200;
|
|
const tank = await Tank.findOne({ hardwareId: iotTank.hardwareId });
|
|
|
|
let combinedWaterlevel;
|
|
if (tank) {
|
|
combinedWaterlevel = currentWaterlevel + Number(tank.waterlevel);
|
|
} else {
|
|
combinedWaterlevel = currentWaterlevel;
|
|
}
|
|
|
|
await Tank.updateOne({ hardwareId: iotTank.hardwareId }, { $set: { waterlevel: combinedWaterlevel } });
|
|
|
|
console.log(`Waterlevel updated successfully for hardwareId ${iotTank.hardwareId}`);
|
|
console.log(`Previous waterlevel: ${tank ? tank.waterlevel : 0}`);
|
|
console.log(`Current waterlevel: ${currentWaterlevel}`);
|
|
console.log(`Combined waterlevel: ${combinedWaterlevel}`);
|
|
} catch (err) {
|
|
console.error(err);
|
|
}
|
|
}, updateInterval);
|
|
};
|