controllers/VerificationController.js

const asyncHandeler = require("express-async-handler");
const Leaderboard = require("../models/LeaderboardModel");
const Round = require("../models/RoundsModel");
const CollaborativeLeaderboardModel = require("../models/CollaborativeLeaderboardModel");
const {
  getFinalLeaderboard,
  getRound4Leaderboard,
  getRound3Leaderboard,
  getRoundLeaderboard,
} = require("../helpers/LeaderBoardPreFetch");
const RoomModel = require("../models/RoomModel");
const account = require("../models/AuthenticationModel");
const UserModel = require("../models/UserModel");

exports.getVerifyResponse = asyncHandeler(async (req, res) => {
  try {
    let rounds = await Round.find();
    let currentRound = 0;
    let nextRound = 0;
    let date = new Date();
    for (i in rounds) {
      if (date <= rounds[i].EndTime && date >= rounds[i].StartTime) {
        currentRound = rounds[i].Round;
        break;
      }
    }
    for (i in rounds) {
      if (date <= rounds[i].StartTime) {
        nextRound = rounds[i].Round;
        break;
      }
    }
    let response = {
      nextRound: nextRound,
      currentRound: currentRound,
      team: req.team.TeamName,
      time: date,
      serverTime: new Date(),
      status: true,
    };
    if (nextRound === 0) {
      response.message = "Game has ended";
    }
    if (nextRound === 1) {
      response.message = "Round 1 starts in";
      response.time = rounds[0].StartTime;
    } else if (nextRound === 2) {
      response.message = "Round 2 starts in";
      response.time = rounds[1].StartTime;
    } else if (nextRound === 3) {
      response.message = "Round 3 starts in";
      response.time = rounds[2].StartTime;
    } else if (nextRound === 4) {
      response.message = "Round 4 starts in";
      response.time = rounds[3].StartTime;
    }

    if (currentRound === 1) {
      response.message = "Round 1 ends in";
      response.time = rounds[0].EndTime;
    } else if (currentRound === 2) {
      response.message = "Round 2 ends in";
      response.time = rounds[1].EndTime;
    } else if (currentRound === 3) {
      response.message = "Round 3 ends in";
      response.time = rounds[2].EndTime;
    } else if (currentRound === 4) {
      response.message = "Round 4 ends in";
      response.time = rounds[3].EndTime;
    }
    let board = await Leaderboard.findOne({ TeamID: req.team._id, Round: 0 });
    response.points = board.Points;
    res.json(response);
  } catch (err) {
    console.log(err);
    res.status(500).json({
      message: err.message,
    });
  }
});
exports.getMainLeaderboard = asyncHandeler(async (req, res) => {
  let rounds = await Round.find();
  let resp = {};
  resp.group = 1;
  resp.TeamName = req.team.TeamName;
  let prevRound = 0;
  let date = new Date();
  for (let i in rounds) {
    if (date > rounds[i].EndTime) {
      prevRound = rounds[i].Round;
    }
  }
  //console.log(prevRound);
  if (prevRound === 0) {
    resp.LB = [];
    resp.LB.push(await getFinalLeaderboard());

    if (resp.LB) resp.status = true;
    else {
      resp.status = false;
      resp.message = "Leaderboard is not available";
    }
  }
  if (prevRound === 2) {
    resp.LB = await getRoundLeaderboard(2);
    if (resp.LB) resp.status = true;
    else {
      resp.status = false;
      resp.message = "Leaderboard is not available";
    }
    let rooms = await RoomModel.find({ Round: 2 });

    resp.group =
      rooms.findIndex((room) => {
        room._id === req.team.RoomID;
      }) + 1;
  }
  if (prevRound === 1) {
    resp.LB = await getRoundLeaderboard(1);
    if (resp.LB) resp.status = true;
    else {
      resp.status = false;
      resp.message = "Leaderboard is not available";
    }
    let rooms = await RoomModel.find({ Round: 1 });

    resp.group =
      rooms.findIndex((room) => {
        room._id === req.team.RoomID;
      }) + 1;
  }
  if (prevRound === 4) {
    resp.LB = [];
    resp.LB.push(await getRound4Leaderboard());
    if (resp.LB) resp.status = true;
    else {
      resp.status = false;
      resp.message = "Leaderboard is not available";
    }
  }
  if (prevRound === 3) {
    resp.LB = [];
    resp.LB.push(await getRound3Leaderboard());
    if (resp.LB) resp.status = true;
    else {
      resp.status = false;
      resp.message = "Leaderboard is not available";
    }
  }
  res.json(resp);
});
module.exports.getstart = asyncHandeler(async (req, res) => {
  let rounds = await Round.find();
  let resp = {};
  resp.status = false;
  let date = new Date();
  for (i in rounds) {
    if (date <= rounds[i].EndTime && date >= rounds[i].StartTime) {
      resp.Round = rounds[i].Round;
      resp.StartTime = rounds[i].StartTime;
      resp.EndTime = rounds[i].EndTime;
      resp.status = true;
      break;
    } else if (date <= rounds[i].StartTime) {
      resp.Round = rounds[i].Round;
      resp.StartTime = rounds[i].StartTime;
      resp.EndTime = rounds[i].EndTime;
      resp.status = true;
      break;
    }
  }
  res.json(resp);
});

module.exports.getDelete = asyncHandeler(async (req, res) => {
  await account.findOneAndDelete({ UserID: req.user._id });
  res.clearCookie("SessionID");
  let resp = {};
  resp.status = true;
  resp.message = "Cookie Deleted";
  res.send(resp);
});

module.exports.getMembers = asyncHandeler(async (req, res) => {
  try {
    let members = req.team.Members;
    let names = [];
    for (i in members) {
      let user = await UserModel.findOne({ _id: members[i] });
      if (user) {
        names.push({
          Name: user.Name,
          Discord: user.DiscordID,
          Role: user.Role,
        });
      }
    }

    res.json({
      members: names,
      status: true,
    });
  } catch (error) {
    res.status(500).json({
      message: error.message,
      status: false,
    });
  }
});