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

const Tank = require("../models/tanks");
const User = require("../models/User");
const boom = require("boom");
const fastify = require("fastify")({
  logger: true,
});
const tanksController = require("./tanksController")






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,
      tankName: req.body.tankName,
      blockName: req.body.blockName,
      capacity: req.body.capacity,
      typeOfWater: req.body.typeOfWater,
   
      tankLocation:req.body.tankLocation,
    };
    
    var tank_name = req.body.tankName
    var tankLocation = req.body.tankLocation
    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.tankName = usertobeInserted.tankName;
      tank.blockName = usertobeInserted.blockName;
      tank.capacity = usertobeInserted.capacity;
      tank.typeOfWater = usertobeInserted.typeOfWater;
    
      tank.tankLocation = usertobeInserted.tankLocation;
    }
  }
    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 = capacity - 100; // initial water level

      const intervalId = setInterval(async function () {
        const newWaterLevel = Math.floor(waterLevel / 1.5);

        const result = await Tank.findOneAndUpdate(
          { _id: tankId },
          { $set: { waterlevel: newWaterLevel } }
        );

        console.log(result);

        if (newWaterLevel === 0) {
          clearInterval(intervals[tankId]);
          console.log(`Stopped updating tank with ID ${tankId}`);
          return;
        }

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

        let waterLevel = capacity - 100; // initial water level
        const intervalId = setInterval(async function () {
          const newWaterLevel = Math.floor(waterLevel / 1.5);
  
          const result = await Tank.findOneAndUpdate(
            { customerId, tankName, },
            { $set: { waterlevel: newWaterLevel } }
          );
  
          console.log(result);
  
          if (newWaterLevel === 0) {
            clearInterval(intervals[tankName]);
            console.log(`Stopped updating ${tankName}`);
            return;
          }
  
          waterLevel = newWaterLevel;
        }, 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);
  }
};

const changingfrom_tankwaterlevel = async (customerId,initial_update,supplier_tank_info) => {
 //console.log(customerId,"0")
 //console.log(update_level,"1")
 //console.log(fromSump,"2")
 
  var result = await Tank.findOneAndUpdate(
    {customerId:customerId, tankName: supplier_tank_info.tankName}, { $set: { waterlevel: initial_update } }
  );

  return result.waterlevel;
};




exports.motorAction = async (req, reply) => {
  try {
    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});
    const receiver_capacity = receiver_tank_info.capacity 
      
    if(action === "start"){
      supplier_tank = req.body.from
      supplier_tank_type = req.body.from_type
      
      if(supplier_tank_type==="sump"){
        const supplier_tank_info = await Tank.findOne({ customerId ,tankName:supplier_tank});
        initial_update = parseInt(supplier_tank_info.capacity.replace(/,/g, ''), 10)-200;
        
        await changingfrom_tankwaterlevel(customerId,initial_update,supplier_tank_info);
        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 () {
          // Calculate new water levels
          const newWaterLevel = receiver_waterlevel  + 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)
        
          // Check if updating should stop
          if ((newSupplierWaterLevel/supplier_capacity)*100 <= 5 || (newWaterLevel/receiver_capacity)*100 >= 95) {
            clearInterval(intervalId)
            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"){
        const supplier_tank_info = await Tank.findOne({ customerId ,tankName:supplier_tank});
        initial_update = parseInt(supplier_tank_info.capacity.replace(/,/g, ''), 10)-200;
        
        await changingfrom_tankwaterlevel(customerId,initial_update,supplier_tank_info);
        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 supplier_capacity = parseInt(supplier_tank_info.capacity.replace(/,/g, ''), 10)
          // Calculate new water levels
          const newWaterLevel = receiver_waterlevel  + Math.floor(supplier_waterlevel  * 0.1);
          const newSupplierWaterLevel = Math.min(supplier_capacity, supplier_waterlevel + Math.floor(supplier_waterlevel * 0.15));

          // Check if updating should stop
          if ((newSupplierWaterLevel/supplier_capacity)*100 <= 5 || (newWaterLevel/receiver_capacity)*100 >= 95) {
            clearInterval(intervalId)
            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);


      }

    }
    
    else if (action === "stop") {
          clearInterval(intervalId);
      } 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}`);

  };
};