368 lines
11 KiB
Go
368 lines
11 KiB
Go
package handlers
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/web_server/response"
|
|
"github.com/gofiber/fiber/v2"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
// @Summary Retrieve all upcoming events
|
|
// @Description Retrieve all upcoming events from the database
|
|
// @Tags prematch
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param page query int false "Page number"
|
|
// @Param page_size query int false "Page size"
|
|
// @Param league_id query string false "League ID Filter"
|
|
// @Param sport_id query string false "Sport ID Filter"
|
|
// @Param cc query string false "Country Code Filter"
|
|
// @Param first_start_time query string false "Start Time"
|
|
// @Param last_start_time query string false "End Time"
|
|
// @Success 200 {array} domain.UpcomingEvent
|
|
// @Failure 500 {object} response.APIResponse
|
|
// @Router /api/v1/events [get]
|
|
func (h *Handler) GetAllUpcomingEvents(c *fiber.Ctx) error {
|
|
page := c.QueryInt("page", 1)
|
|
pageSize := c.QueryInt("page_size", 10)
|
|
limit := domain.ValidInt64{
|
|
Value: int64(pageSize),
|
|
Valid: true,
|
|
}
|
|
offset := domain.ValidInt64{
|
|
Value: int64(page - 1),
|
|
Valid: true,
|
|
}
|
|
|
|
leagueIDQuery := c.Query("league_id")
|
|
var leagueID domain.ValidInt32
|
|
if leagueIDQuery != "" {
|
|
leagueIDInt, err := strconv.Atoi(leagueIDQuery)
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Error("invalid league id",
|
|
zap.String("league_id", leagueIDQuery),
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, "invalid league id")
|
|
}
|
|
leagueID = domain.ValidInt32{
|
|
Value: int32(leagueIDInt),
|
|
Valid: true,
|
|
}
|
|
}
|
|
sportIDQuery := c.Query("sport_id")
|
|
var sportID domain.ValidInt32
|
|
if sportIDQuery != "" {
|
|
sportIDint, err := strconv.Atoi(sportIDQuery)
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Info("invalid sport id",
|
|
zap.String("sportID", sportIDQuery),
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, "invalid sport id")
|
|
}
|
|
sportID = domain.ValidInt32{
|
|
Value: int32(sportIDint),
|
|
Valid: true,
|
|
}
|
|
}
|
|
|
|
searchQuery := c.Query("query")
|
|
searchString := domain.ValidString{
|
|
Value: searchQuery,
|
|
Valid: searchQuery != "",
|
|
}
|
|
|
|
firstStartTimeQuery := c.Query("first_start_time")
|
|
var firstStartTime domain.ValidTime
|
|
if firstStartTimeQuery != "" {
|
|
firstStartTimeParsed, err := time.Parse(time.RFC3339, firstStartTimeQuery)
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Info("invalid start_time format",
|
|
zap.String("first_start_time", firstStartTimeQuery),
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, "Invalid start_time format")
|
|
}
|
|
firstStartTime = domain.ValidTime{
|
|
Value: firstStartTimeParsed,
|
|
Valid: true,
|
|
}
|
|
}
|
|
|
|
lastStartTimeQuery := c.Query("last_start_time")
|
|
var lastStartTime domain.ValidTime
|
|
if lastStartTimeQuery != "" {
|
|
lastStartTimeParsed, err := time.Parse(time.RFC3339, lastStartTimeQuery)
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Info("invalid last_start_time format",
|
|
zap.String("last_start_time", lastStartTimeQuery),
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, "Invalid start_time format")
|
|
}
|
|
lastStartTime = domain.ValidTime{
|
|
Value: lastStartTimeParsed,
|
|
Valid: true,
|
|
}
|
|
}
|
|
|
|
countryCodeQuery := c.Query("cc")
|
|
countryCode := domain.ValidString{
|
|
Value: countryCodeQuery,
|
|
Valid: countryCodeQuery != "",
|
|
}
|
|
|
|
isFeaturedQuery := c.Query("is_featured")
|
|
var isFeatured domain.ValidBool
|
|
if isFeaturedQuery != "" {
|
|
isFeaturedParsed, err := strconv.ParseBool(isFeaturedQuery)
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Error("Failed to parse isFeatured",
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, "Failed to parse is_shop_bet")
|
|
}
|
|
|
|
isFeatured = domain.ValidBool{
|
|
Value: isFeaturedParsed,
|
|
Valid: true,
|
|
}
|
|
}
|
|
|
|
events, total, err := h.eventSvc.GetPaginatedUpcomingEvents(
|
|
c.Context(), domain.EventFilter{
|
|
SportID: sportID,
|
|
LeagueID: leagueID,
|
|
Query: searchString,
|
|
FirstStartTime: firstStartTime,
|
|
LastStartTime: lastStartTime,
|
|
Limit: limit,
|
|
Offset: offset,
|
|
CountryCode: countryCode,
|
|
Featured: isFeatured,
|
|
})
|
|
|
|
// fmt.Printf("League ID: %v", leagueID)
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Error("Failed to retrieve all upcoming events",
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, err.Error())
|
|
}
|
|
|
|
return response.WritePaginatedJSON(c, fiber.StatusOK, "All upcoming events retrieved successfully", events, nil, page, int(total))
|
|
|
|
}
|
|
|
|
type TopLeaguesRes struct {
|
|
Leagues []TopLeague `json:"leagues"`
|
|
}
|
|
|
|
type TopLeague struct {
|
|
LeagueID int64 `json:"league_id"`
|
|
LeagueName string `json:"league_name"`
|
|
LeagueCC string `json:"league_cc"`
|
|
LeagueSportID int32 `json:"league_sport_id"`
|
|
Events []domain.UpcomingEvent `json:"events"`
|
|
// Total int64 `json:"total"`
|
|
}
|
|
|
|
// @Summary Retrieve all top leagues
|
|
// @Description Retrieve all top leagues
|
|
// @Tags prematch
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Success 200 {array} TopLeague
|
|
// @Failure 500 {object} response.APIResponse
|
|
// @Router /api/v1/top-leagues [get]
|
|
func (h *Handler) GetTopLeagues(c *fiber.Ctx) error {
|
|
|
|
leagues, err := h.leagueSvc.GetFeaturedLeagues(c.Context())
|
|
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Error("Error while fetching top leagues",
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, err.Error())
|
|
}
|
|
|
|
var topLeague []TopLeague = make([]TopLeague, 0, len(leagues))
|
|
for _, league := range leagues {
|
|
events, _, err := h.eventSvc.GetPaginatedUpcomingEvents(
|
|
c.Context(), domain.EventFilter{
|
|
LeagueID: domain.ValidInt32{
|
|
Value: int32(league.ID),
|
|
Valid: true,
|
|
},
|
|
})
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Warn("Error while fetching events for top league",
|
|
zap.Int64("LeagueID", league.ID),
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
}
|
|
topLeague = append(topLeague, TopLeague{
|
|
LeagueID: league.ID,
|
|
LeagueName: league.Name,
|
|
LeagueCC: league.CountryCode,
|
|
LeagueSportID: league.SportID,
|
|
Events: events,
|
|
})
|
|
}
|
|
|
|
res := TopLeaguesRes{
|
|
Leagues: topLeague,
|
|
}
|
|
return response.WriteJSON(c, fiber.StatusOK, "All top leagues events retrieved successfully", res, nil)
|
|
|
|
}
|
|
|
|
// @Summary Retrieve an upcoming by ID
|
|
// @Description Retrieve an upcoming event by ID
|
|
// @Tags prematch
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id path string true "ID"
|
|
// @Success 200 {object} domain.UpcomingEvent
|
|
// @Failure 400 {object} response.APIResponse
|
|
// @Failure 500 {object} response.APIResponse
|
|
// @Router /api/v1/events/{id} [get]
|
|
func (h *Handler) GetUpcomingEventByID(c *fiber.Ctx) error {
|
|
|
|
id := c.Params("id")
|
|
if id == "" {
|
|
h.mongoLoggerSvc.Info("Failed to parse event id",
|
|
zap.String("id", id),
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, "Missing id")
|
|
}
|
|
|
|
event, err := h.eventSvc.GetUpcomingEventByID(c.Context(), id)
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Error("Failed to get upcoming event by id",
|
|
zap.String("eventID", id),
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, err.Error())
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Upcoming event retrieved successfully", event, nil)
|
|
|
|
}
|
|
|
|
type UpdateEventStatusReq struct {
|
|
}
|
|
|
|
// SetEventStatusToRemoved godoc
|
|
// @Summary Set the event status to removed
|
|
// @Description Set the event status to removed
|
|
// @Tags event
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id path int true "Event ID"
|
|
// @Success 200 {object} response.APIResponse
|
|
// @Failure 400 {object} response.APIResponse
|
|
// @Failure 500 {object} response.APIResponse
|
|
// @Router /api/v1/events/{id} [delete]
|
|
func (h *Handler) SetEventStatusToRemoved(c *fiber.Ctx) error {
|
|
eventID := c.Params("id")
|
|
err := h.eventSvc.UpdateEventStatus(c.Context(), eventID, domain.STATUS_REMOVED)
|
|
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Error("Failed to update event status",
|
|
zap.String("EventID", eventID),
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to update event status")
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Event updated successfully", nil, nil)
|
|
|
|
}
|
|
|
|
type UpdateEventFeaturedReq struct {
|
|
Featured bool `json:"is_featured" example:"true"`
|
|
}
|
|
|
|
// UpdateEventFeatured godoc
|
|
// @Summary update the event featured
|
|
// @Description Update the event featured
|
|
// @Tags event
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id path int true "Event ID"
|
|
// @Success 200 {object} response.APIResponse
|
|
// @Failure 400 {object} response.APIResponse
|
|
// @Failure 500 {object} response.APIResponse
|
|
// @Router /api/v1/events/{id}/flag [put]
|
|
func (h *Handler) UpdateEventFeatured(c *fiber.Ctx) error {
|
|
eventID := c.Params("id")
|
|
|
|
var req UpdateEventFeaturedReq
|
|
|
|
if err := c.BodyParser(&req); err != nil {
|
|
h.mongoLoggerSvc.Info("Failed to parse user id",
|
|
zap.String("eventID", eventID),
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, err.Error())
|
|
}
|
|
|
|
valErrs, ok := h.validator.Validate(c, req)
|
|
if !ok {
|
|
var errMsg string
|
|
for field, msg := range valErrs {
|
|
errMsg += fmt.Sprintf("%s: %s; ", field, msg)
|
|
}
|
|
h.mongoLoggerSvc.Error("Failed to update event featured",
|
|
zap.Any("request", req),
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, errMsg)
|
|
}
|
|
err := h.eventSvc.UpdateFeatured(c.Context(), eventID, req.Featured)
|
|
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Error("Failed to update event featured",
|
|
zap.String("eventID", eventID),
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, err.Error())
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Event updated successfully", nil, nil)
|
|
|
|
}
|