Untitled

const express = require("express");
const { body, validationResult } = require("express-validator");
const SelectedLeagues = require("../../models/SelectedLeagues");
const { redisCacheServer } = require("../../utils/getAxios");

const router = express.Router();

// Validation middleware
const validate = (validations) => {
  return async (req, res, next) => {
    await Promise.all(validations.map((validation) => validation.run(req)));

    const errors = validationResult(req);
    if (errors.isEmpty()) {
      return next();
    }

    res.status(400).json({ errors: errors.array() });
  };
};

// Validation rules
const validateSelectedLeague = [
  body("id").isNumeric(),
  body("name").notEmpty(),
  body("logo").notEmpty(),
  body("status").isString()
];

// Get all selected leagues and sort by position
router.get("/", async (req, res, next) => {
  try {
    const selectedLeagues = await SelectedLeagues.find().sort({ position: 1 }); // Sort by position ascending

    // Remove unwanted fields from selectedLeagues
    const sanitizedLeagues = selectedLeagues.map((league) => {
      const { createdAt, status, position, updatedAt, __v, ...rest } = league.toObject();
      return rest;
    });

    res.json({
      status: true,
      message: "Selected leagues fetched and sorted",
      data: sanitizedLeagues
    });
  } catch (error) {
    next(error);
  }
});

// Get a specific selected league
router.get("/:id", async (req, res, next) => {
  try {
    const selectedLeague = await SelectedLeagues.findById(req.params.id);
    res.json({ status: true, message: "Selected leagues fetched", data: selectedLeague });
  } catch (error) {
    next(error);
  }
});

// Create a new selected league
router.post("/", validate(validateSelectedLeague), async (req, res, next) => {
  const LeagueData = {
    id: req.body.id,
    name: req.body.name,
    logo: req.body.logo,
    status: req.body.status || "1",
    position: req.body.position || 9999999
  };

  // Create a new selected league
  const selectedLeague = new SelectedLeagues(LeagueData);

  try {
    const newSelectedLeague = await selectedLeague.save();

    console.log("newSelectedLeague", newSelectedLeague);

    const cacheRes = await redisCacheServer.post("api/league", LeagueData);

    console.log("Cache res", cacheRes);

    res.status(201).json({ status: true, message: "Selected leagues created", data: newSelectedLeague });
  } catch (error) {
    next(error);
  }
});

// Update a selected league
router.patch("/:id", validate(validateSelectedLeague), async (req, res, next) => {
  try {
    const updatedSelectedLeague = await SelectedLeagues.findByIdAndUpdate(
      req.params.id,
      {
        id: req.body.id,
        name: req.body.name,
        logo: req.body.logo,
        status: req.body.status || "1",
        position: req.body.position || 9999999
      },
      { new: true }
    );

    if (!updatedSelectedLeague) {
      return res.status(404).json({ status: false, message: "Selected league not found" });
    }

    res.json({ status: true, message: "Selected leagues Updated", data: updatedSelectedLeague });
  } catch (error) {
    next(error);
  }
});

// Delete a selected league
router.delete("/:id", async (req, res, next) => {
  try {
    const deletedSelectedLeague = await SelectedLeagues.findByIdAndDelete(req.params.id);

    const data = { id: deletedSelectedLeague.id };

    console.log("leagueDelete", data);

    if (!deletedSelectedLeague) {
      return res.status(404).json({ status: false, message: "Selected league not found" });
    } else {
      const leagueDelete = await redisCacheServer.delete(`api/league/delete/${deletedSelectedLeague.id}`);
      return res.json({ status: true, message: "Selected league deleted successfully" });
    }
  } catch (error) {
    next(error);
  }
});

// Sort Selected Leagues
router.post("/sort", async (req, res, next) => {
  try {
    let leagueData = req.body;

    await Promise.all(
      leagueData.map(async (league) => {
        const sortedLeagues = await SelectedLeagues.findByIdAndUpdate(league.id, {
          position: league.position
        });
        return sortedLeagues;
      })
    );

    console.log("leagueData", leagueData);

    const sortLeague = await redisCacheServer.post("api/league/sort", leagueData);

    console.log("After sort", sortLeague);

    return res.status(200).json({
      status: true,
      message: "Selected Leagues Sorted Successfully!"
    });
  } catch (error) {
    console.error(error);
    next(error);
  }
});

module.exports = router;