320 lines
10 KiB
Go
320 lines
10 KiB
Go
package handlers
|
|
|
|
import (
|
|
"log"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
|
|
"github.com/gofiber/fiber/v2"
|
|
)
|
|
|
|
// GetPreMatchOdds godoc
|
|
// @Summary Get pre-match odds for an event
|
|
// @Description Fetches pre-match odds from EnetPulse for a given event
|
|
// @Tags EnetPulse - PreMatch
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param objectFK query int true "Event ID"
|
|
// @Param oddsProviderFK query []int false "Odds provider IDs (comma separated)"
|
|
// @Param outcomeTypeFK query int false "Outcome type ID"
|
|
// @Param outcomeScopeFK query int false "Outcome scope ID"
|
|
// @Param outcomeSubtypeFK query int false "Outcome subtype ID"
|
|
// @Param limit query int false "Limit results"
|
|
// @Param offset query int false "Offset results"
|
|
// @Param languageTypeFK query int false "Language type ID"
|
|
// @Success 200 {object} domain.Response{data=domain.PreMatchOddsResponse}
|
|
// @Failure 400 {object} domain.ErrorResponse
|
|
// @Failure 502 {object} domain.ErrorResponse
|
|
// @Router /api/v1/odds/pre-match [get]
|
|
func (h *Handler) GetPreMatchOdds(c *fiber.Ctx) error {
|
|
// Parse query parameters
|
|
objectFK := c.QueryInt("objectFK")
|
|
if objectFK == 0 {
|
|
return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
|
|
Message: "Event ID (objectFK) is required",
|
|
Error: "missing or invalid objectFK",
|
|
})
|
|
}
|
|
|
|
params := domain.PreMatchOddsRequest{
|
|
ObjectFK: int64(objectFK),
|
|
OddsProviderFK: intSliceToInt64Slice(parseIntSlice(c.Query("oddsProviderFK"))), // convert []int to []int64
|
|
OutcomeTypeFK: int64(c.QueryInt("outcomeTypeFK")),
|
|
OutcomeScopeFK: int64(c.QueryInt("outcomeScopeFK")),
|
|
OutcomeSubtypeFK: int64(c.QueryInt("outcomeSubtypeFK")),
|
|
Limit: c.QueryInt("limit"),
|
|
Offset: c.QueryInt("offset"),
|
|
LanguageTypeFK: int64(c.QueryInt("languageTypeFK")),
|
|
}
|
|
|
|
// Call service
|
|
res, err := h.enetPulseSvc.FetchPreMatchOdds(c.Context(), params)
|
|
if err != nil {
|
|
log.Println("FetchPreMatchOdds error:", err)
|
|
return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
|
|
Message: "Failed to fetch pre-match odds",
|
|
Error: err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.Status(fiber.StatusOK).JSON(domain.Response{
|
|
Message: "Pre-match odds fetched successfully",
|
|
Data: res,
|
|
StatusCode: fiber.StatusOK,
|
|
Success: true,
|
|
})
|
|
}
|
|
|
|
// GetAllSports godoc
|
|
// @Summary Get all sports
|
|
// @Description Fetches all sports stored in the database
|
|
// @Tags EnetPulse - Sports
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Success 200 {object} domain.Response{data=[]domain.EnetpulseSport}
|
|
// @Failure 502 {object} domain.ErrorResponse
|
|
// @Router /api/v1/enetpulse/sports [get]
|
|
func (h *Handler) GetAllSports(c *fiber.Ctx) error {
|
|
// Call service
|
|
sports, err := h.enetPulseSvc.GetAllSports(c.Context())
|
|
if err != nil {
|
|
log.Println("GetAllSports error:", err)
|
|
return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
|
|
Message: "Failed to fetch sports",
|
|
Error: err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.Status(fiber.StatusOK).JSON(domain.Response{
|
|
Message: "Sports fetched successfully",
|
|
Data: sports,
|
|
StatusCode: fiber.StatusOK,
|
|
Success: true,
|
|
})
|
|
}
|
|
|
|
// GetAllTournamentTemplates godoc
|
|
// @Summary Get all tournament templates
|
|
// @Description Fetches all tournament templates stored in the database
|
|
// @Tags EnetPulse - Tournament Templates
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Success 200 {object} domain.Response{data=[]domain.EnetpulseTournamentTemplate}
|
|
// @Failure 502 {object} domain.ErrorResponse
|
|
// @Router /api/v1/enetpulse/tournament-templates [get]
|
|
func (h *Handler) GetAllTournamentTemplates(c *fiber.Ctx) error {
|
|
// Call service
|
|
templates, err := h.enetPulseSvc.GetAllTournamentTemplates(c.Context())
|
|
if err != nil {
|
|
log.Println("GetAllTournamentTemplates error:", err)
|
|
return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
|
|
Message: "Failed to fetch tournament templates",
|
|
Error: err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.Status(fiber.StatusOK).JSON(domain.Response{
|
|
Message: "Tournament templates fetched successfully",
|
|
Data: templates,
|
|
StatusCode: fiber.StatusOK,
|
|
Success: true,
|
|
})
|
|
}
|
|
|
|
// GetAllTournaments godoc
|
|
// @Summary Get all tournaments
|
|
// @Description Fetches all tournaments stored in the database
|
|
// @Tags EnetPulse - Tournaments
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Success 200 {object} domain.Response{data=[]domain.EnetpulseTournament}
|
|
// @Failure 502 {object} domain.ErrorResponse
|
|
// @Router /api/v1/enetpulse/tournaments [get]
|
|
func (h *Handler) GetAllTournaments(c *fiber.Ctx) error {
|
|
// Call service
|
|
tournaments, err := h.enetPulseSvc.GetAllTournaments(c.Context())
|
|
if err != nil {
|
|
log.Println("GetAllTournaments error:", err)
|
|
return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
|
|
Message: "Failed to fetch tournaments",
|
|
Error: err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.Status(fiber.StatusOK).JSON(domain.Response{
|
|
Message: "Tournaments fetched successfully",
|
|
Data: tournaments,
|
|
StatusCode: fiber.StatusOK,
|
|
Success: true,
|
|
})
|
|
}
|
|
|
|
// GetAllTournamentStages godoc
|
|
// @Summary Get all tournament stages
|
|
// @Description Fetches all tournament stages stored in the database
|
|
// @Tags EnetPulse - Tournament Stages
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Success 200 {object} domain.Response{data=[]domain.EnetpulseTournamentStage}
|
|
// @Failure 502 {object} domain.ErrorResponse
|
|
// @Router /api/v1/enetpulse/tournament-stages [get]
|
|
func (h *Handler) GetAllTournamentStages(c *fiber.Ctx) error {
|
|
// Call service
|
|
stages, err := h.enetPulseSvc.GetAllTournamentStages(c.Context())
|
|
if err != nil {
|
|
log.Println("GetAllTournamentStages error:", err)
|
|
return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
|
|
Message: "Failed to fetch tournament stages",
|
|
Error: err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.Status(fiber.StatusOK).JSON(domain.Response{
|
|
Message: "Tournament stages fetched successfully",
|
|
Data: stages,
|
|
StatusCode: fiber.StatusOK,
|
|
Success: true,
|
|
})
|
|
}
|
|
|
|
// GetFixturesByDate godoc
|
|
// @Summary Get all stored fixtures
|
|
// @Description Fetches all fixtures stored in the database
|
|
// @Tags EnetPulse - Fixtures
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Success 200 {object} domain.Response{data=[]domain.EnetpulseFixture}
|
|
// @Failure 502 {object} domain.ErrorResponse
|
|
// @Router /api/v1/enetpulse/fixtures [get]
|
|
func (h *Handler) GetFixturesByDate(c *fiber.Ctx) error {
|
|
// Call service to get all fixtures from DB
|
|
fixtures, err := h.enetPulseSvc.GetAllFixtures(c.Context())
|
|
if err != nil {
|
|
log.Println("GetAllFixtures error:", err)
|
|
return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
|
|
Message: "Failed to fetch fixtures from database",
|
|
Error: err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.Status(fiber.StatusOK).JSON(domain.Response{
|
|
Message: "Fixtures fetched successfully",
|
|
Data: fixtures,
|
|
StatusCode: fiber.StatusOK,
|
|
Success: true,
|
|
})
|
|
}
|
|
|
|
// GetAllResults godoc
|
|
// @Summary Get all results
|
|
// @Description Fetches all EnetPulse match results stored in the database
|
|
// @Tags EnetPulse - Results
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Success 200 {object} domain.Response{data=[]domain.EnetpulseResult}
|
|
// @Failure 502 {object} domain.ErrorResponse
|
|
// @Router /api/v1/enetpulse/results [get]
|
|
func (h *Handler) GetAllResults(c *fiber.Ctx) error {
|
|
// Call service
|
|
results, err := h.enetPulseSvc.GetAllResults(c.Context())
|
|
if err != nil {
|
|
log.Println("GetAllResults error:", err)
|
|
return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
|
|
Message: "Failed to fetch EnetPulse results",
|
|
Error: err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.Status(fiber.StatusOK).JSON(domain.Response{
|
|
Message: "EnetPulse results fetched successfully",
|
|
Data: results,
|
|
StatusCode: fiber.StatusOK,
|
|
Success: true,
|
|
})
|
|
}
|
|
|
|
// GetAllPreodds godoc
|
|
// @Summary Get all preodds
|
|
// @Description Fetches all EnetPulse pre-match odds stored in the database
|
|
// @Tags EnetPulse - Preodds
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Success 200 {object} domain.Response{data=[]domain.EnetpulsePreodds}
|
|
// @Failure 502 {object} domain.ErrorResponse
|
|
// @Router /api/v1/enetpulse/preodds [get]
|
|
func (h *Handler) GetAllPreodds(c *fiber.Ctx) error {
|
|
// Call service
|
|
preodds, err := h.enetPulseSvc.GetAllPreodds(c.Context())
|
|
if err != nil {
|
|
log.Println("GetAllPreodds error:", err)
|
|
return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
|
|
Message: "Failed to fetch EnetPulse preodds",
|
|
Error: err.Error(),
|
|
})
|
|
}
|
|
|
|
return c.Status(fiber.StatusOK).JSON(domain.Response{
|
|
Message: "EnetPulse preodds fetched successfully",
|
|
Data: preodds,
|
|
StatusCode: fiber.StatusOK,
|
|
Success: true,
|
|
})
|
|
}
|
|
|
|
// GetFixturesWithPreodds godoc
|
|
// @Summary Get fixtures with preodds
|
|
// @Description Fetches all EnetPulse fixtures along with their associated pre-match odds
|
|
// @Tags EnetPulse - Fixtures
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Success 200 {object} domain.Response{data=[]domain.EnetpulseFixtureWithPreodds}
|
|
// @Failure 502 {object} domain.ErrorResponse
|
|
// @Router /api/v1/enetpulse/fixtures/preodds [get]
|
|
func (h *Handler) GetFixturesWithPreodds(c *fiber.Ctx) error {
|
|
// Call service
|
|
fixtures, err := h.enetPulseSvc.GetFixturesWithPreodds(c.Context())
|
|
if err != nil {
|
|
log.Println("GetFixturesWithPreodds error:", err)
|
|
return c.Status(fiber.StatusBadGateway).JSON(domain.ErrorResponse{
|
|
Message: "Failed to fetch EnetPulse fixtures with preodds",
|
|
Error: err.Error(),
|
|
})
|
|
}
|
|
|
|
// Return success response
|
|
return c.Status(fiber.StatusOK).JSON(domain.Response{
|
|
Message: "EnetPulse fixtures with preodds fetched successfully",
|
|
Data: fixtures,
|
|
StatusCode: fiber.StatusOK,
|
|
Success: true,
|
|
})
|
|
}
|
|
|
|
// Helper: parse comma-separated string into []int
|
|
func parseIntSlice(input string) []int {
|
|
if input == "" {
|
|
return nil
|
|
}
|
|
parts := strings.Split(input, ",")
|
|
result := make([]int, 0, len(parts))
|
|
for _, p := range parts {
|
|
if n, err := strconv.Atoi(strings.TrimSpace(p)); err == nil {
|
|
result = append(result, n)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
// Helper: convert []int to []int64
|
|
func intSliceToInt64Slice(input []int) []int64 {
|
|
if input == nil {
|
|
return nil
|
|
}
|
|
result := make([]int64, len(input))
|
|
for i, v := range input {
|
|
result[i] = int64(v)
|
|
}
|
|
return result
|
|
}
|