sport.controllers.ts

import { Request, Response } from "express";
import Boat from "../db/models/Boat";
import BoatHasSport from "../db/models/BoatHasSport";
import Sport from "../db/models/Sport";

//create SportController
const createSportController = async (req: Request, res: Response) => {
  try {
    if (!(res.locals.user.role == "coordinator")) {
      return res
        .status(403)
        .json({ success: false, error: "MustBeCoordinator" });
    }

    const newSportInput = req.body;

    //check if Sport already exists in DB to avoid duplicates
    const findIfSportExists = await Sport.findOne({
      where: { name: newSportInput.name },
    });

    if (findIfSportExists) {
      return res
        .status(404)
        .json({ success: false, error: "sportAlreadyExists" });
    }

    //check if color already assigned to another sport (for the statistics)
    if (!(newSportInput.color === undefined)) {
      const findIfColorAlreadyAssigned = await Sport.findOne({
        where: {
          color: newSportInput.color,
        },
      });
      if (findIfColorAlreadyAssigned) {
        return res
          .status(404)
          .json({ success: false, error: "givenSportColorAlreadyExists" });
      }
    }

    const newSport = await Sport.create(newSportInput);

    if (newSport) {
      return res.status(201).json({
        success: true,
        result: {
          id: newSport.id,
          name: newSport.name,
          color: newSport.color,
        },
      });
    }
  } catch (error) {
    console.error(error.message);
    return res.status(500).json({ success: false, error: "serverError" });
  }
};

//show all Sports
const showAllSports = async (req: Request, res: Response) => {
  try {
    if (!(res.locals.user.role === "coordinator")) {
      return res
        .status(403)
        .json({ success: false, error: "MustBeCoordinator" });
    }
    const allSports = await Sport.findAll();
    return res.status(200).send({
      success: true,
      result: allSports.map((Sport) => {
        return { id: Sport.id, name: Sport.name };
      }),
    });
  } catch (error) {
    console.error("server error: ", error.message);
    return res.status(500).json({ success: false, error: "serverError" });
  }
};

// delete a Sport by using given sport ID
const deleteSportById = async (req: Request, res: Response) => {
  try {
    //check authority
    if (!(res.locals.user.role === "coordinator")) {
      return res
        .status(403)
        .json({ success: false, error: "MustBeCoordinator" });
    }
    //delete using given id
    const givenId = req.params.id;

    //first we need to destroy entries where the to-be-deleted sport is assigned to boat in BoatHasSport table, because it violates the foreign constraint
    await BoatHasSport.destroy({
      where: {
        sportid: givenId,
      },
    });

    const sportToDelete = await Sport.destroy({
      where: {
        id: givenId,
      },
    });

    if (sportToDelete == 0) {
      return res
        .status(404)
        .json({ success: false, error: "sportIdDoesNotExist" });
    }

    return res.status(204).json({ success: true });
  } catch (error) {
    console.error("server error: ", error.message);
    return res.status(500).json({ success: false, error: "serverError" });
  }
};

//update sport by given sport id
const updateSportById = async (req: Request, res: Response) => {
  try {
    //check authority
    if (!(res.locals.user.role === "coordinator")) {
      return res
        .status(403)
        .json({ success: false, error: "MustBeCoordinator" });
    }

    //get new input
    const input = req.body;

    //return 200 with empty response if no data was given
    if (Object.keys(input).length === 0) {
      return res
        .status(200)
        .json({ success: true, result: {}, message: "noInputFound" });
    }

    //get id
    const givenId = req.params.id;

    //check if sport can be found using givenId
    const foundSport = await Sport.findByPk(givenId);

    if (!foundSport) {
      return res.status(404).json({ success: false, error: "sportIdNotFound" });
    }

    //check if updated name of the new sport already exists in DB
    if (!(input.name === undefined)) {
      const findIfNameAlreadyExists = await Sport.findOne({
        where: {
          name: input.name,
        },
      });
      if (findIfNameAlreadyExists) {
        return res
          .status(404)
          .json({ success: false, error: "givenSportNameAlreadyExists" });
      }
    }

    //check if color already assigned to another sport (for the statistics)
    if (!(input.color === undefined)) {
      const findIfColorAlreadyAssigned = await Sport.findOne({
        where: {
          color: input.color,
        },
      });
      if (findIfColorAlreadyAssigned) {
        return res
          .status(404)
          .json({ success: false, error: "givenSportColorAlreadyExists" });
      }
    }

    //try to update
    const updatedSport = await Sport.update(input, {
      where: {
        id: givenId,
      },
      returning: true,
    });

    //return after updating
    const sportDataAfterUpdate = updatedSport[1][0];
    return res.status(200).json({
      success: true,
      result: {
        id: sportDataAfterUpdate.id,
        name: sportDataAfterUpdate.name,
        color: sportDataAfterUpdate.color,
      },
    });
  } catch (error) {
    console.error("server error: ", error.message);
    return res.status(500).json({ success: false, error: "serverError" });
  }
};

//show all sports assigned to boat by given boatid
const showSportByBoatId = async (req: Request, res: Response) => {
  try {
    if (!(res.locals.user.role === "coordinator")) {
      return res
        .status(403)
        .json({ success: false, error: "MustBeCoordinator" });
    }
    const givenId = req.params.id;
    const boat = await Boat.findByPk(givenId);
    if (boat) {
      //if boat exists check in BoatHasSport table if there are any sports assigned to Boat
      const boatIdInBoatHasSport = await BoatHasSport.findByPk(givenId);

      if (!boatIdInBoatHasSport) {
        return res
          .status(404)
          .json({ success: false, error: "noAssignedSportToBoatId" });
      }

      const findAllBoatId = await BoatHasSport.findAll({
        where: {
          boatid: givenId,
        },
      });

      //define empty array, where we store founded names of sports assigned to boat's id
      var list = new Array();

      for (let i = 0; i < findAllBoatId.length; i++) {
        const found = await Sport.findByPk(findAllBoatId[i].sportid);
        list.push(found.name);
      }
      //return as response the names of the sports
      return res.status(200).json({ success: true, result: { sport: list } });
    }
    return res.status(404).json({ success: false, error: "boatIdNotFound" });
  } catch (error) {
    console.error("server error: ", error.message);
    return res.status(500).json({ success: false, error: "serverError" });
  }
};

const showSportBySportId = async (req: Request, res: Response) => {
  try {
    if (!(res.locals.user.role === "coordinator")) {
      return res
        .status(403)
        .json({ success: false, error: "MustBeCoordinator" });
    }
    const givenId = req.params.id;
    const sport = await Sport.findByPk(givenId);
    if (sport) {
      return res.status(200).json({
        success: true,
        result: { id: givenId, name: sport.name, color: sport.color },
      });
    }
    return res.status(404).json({ success: false, error: "sportIdNotFound" });
  } catch (error) {
    console.error("server error: ", error.message);
    return res.status(500).json({ success: false, error: "serverError" });
  }
};

const sportControllers = {
  createSportController,
  showAllSports,
  deleteSportById,
  updateSportById,
  showSportByBoatId,
  showSportBySportId,
};

export default sportControllers;