watermanagement-backend-prod/src/controllers/tanksController.js

//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 {
    var customerId = req.params.customerId;
    var tankName = req.query.tankName;
    const tank = await Tank.findOneAndDelete({ tankName: tankName,customerId:customerId });

    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;
      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(result);

        

        waterLevel = newWaterLevel;
      }, 2000);

      intervals[tankId] = intervalId;
    }

    return { message: 'Water level updates started' };
  } catch (err) {
    throw boom.boomify(err);
  }
};



exports.updateTanklevels1 = async (req, reply) => {
    try {
      const customerId = req.params.customerId;
      const tanks = await Tank.find({ customerId });
  
      const intervals = {};
  
      for (const tank of tanks) {
        const tankName = tank.tankName;
        const tank_type = tank.tankLocation
        let capacity = parseInt(tank.capacity.replace(/,/g, ''), 10);

        const waterLevel = parseInt(tank.waterLevel.replace(/,/g, ''), 10);
        //capacity - 100; // initial water level
        const intervalId = setInterval(async function () {
          const motor_status = tank.motor_status
          if(motor_status === "0"){
            const newWaterLevel = Math.floor(waterLevel - 200);
            console.log(tank.tankName,newWaterLevel)
          const result = await Tank.findOneAndUpdate(
            { customerId, tankName, },
            { $set: { waterlevel: newWaterLevel } }
          );
          if (newWaterLevel === 0) {
            clearInterval(intervals[tankName]);
            console.log(`Stopped updating ${tankName}`);
            return;
          }
  
          waterLevel = newWaterLevel;

          }
          else{
            if(tank.tankLocation==="overhead",motor_status==="1"){
              tank_waterlevel = math.floor(waterLevel + 250)
              const supplier_water= await findOne({customerId:req.params.customerId,tankName:req.body.from,tankLocation:req.body.from_type})
              const supplier_waterlevel =  parseInt(supplier_water.waterlevel .replace(/,/g, ''), 10);
              const newSupplierWaterLevel = math.floor(supplier_waterlevel - 250)
              
              await Tank.findOneAndUpdate({customerId:req.params.customerId,tankName:req.body.from,tankLocation:req.body.from_type}, { $set: { waterlevel: newSupplierWaterLevel } })
              await tank.save()
            }
            if(tank.tankLocation==="sump",motor_status==="1"){
              const sumpwaterlevel = math.floor(waterLevel + 250)
              await tank.save()
            }


          }
         
  
         // console.log(result);
  
         
         
        }, 2000);
  
        intervals[tankName] = 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 });
  
    reply.send({ status_code: 200, data: updated_data});


  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"){
     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(receiver_tank+""+newWaterLevel+""+"bore to sump")
            //console.log((newWaterLevel/receiver_capacity)*100,"4",receiver_tank_info.tankName)
            await  Tank.findOneAndUpdate({customerId, tankName: receiver_tank,tankLocation:receiver_type}, { $set: { waterlevel: newWaterLevel } })
          }
        }, 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") {
     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==="horizontalcylinder"){
      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==="verticalcylinder"){
    console.log("hii2")
    const { height,diameter } = req.body

   // Ensure all parameters are valid numbers
    if (isNaN(height) || 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) * height
    const capacity = volume * 1000
   
    reply.send({ status_code: 200, capacity: capacity});


    return { message: 'success' };

}
  if(shape==="horizontaloval"){
    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=== "verticaloval"){
  console.log("hii4")
  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 = width / 2
  const a = height - width
  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' };

}

    }

   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.toLocaleDateString('en-IN');
    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);
  }
}