378 lines
13 KiB
Go
378 lines
13 KiB
Go
package handlers
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/pkgs/helpers"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/web_server/response"
|
|
"github.com/gofiber/fiber/v2"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
func (h *Handler) CreateRaffle(c *fiber.Ctx) error {
|
|
var req domain.CreateRaffle
|
|
if err := c.BodyParser(&req); err != nil {
|
|
h.mongoLoggerSvc.Info("Failed to parse raffle request",
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, "Invalid request body")
|
|
}
|
|
|
|
if valErrs, ok := h.validator.Validate(c, req); !ok {
|
|
var errMsg string
|
|
for field, msg := range valErrs {
|
|
errMsg += fmt.Sprintf("%s: %s; ", field, msg)
|
|
}
|
|
h.mongoLoggerSvc.Info("Failed to validate settings",
|
|
zap.String("errMsg", errMsg),
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, errMsg)
|
|
}
|
|
|
|
raffle, err := h.raffleSvc.CreateRaffle(c.Context(), req)
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Error("Failed to create raffle",
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to create raffle")
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Raffle created successfully", raffle, nil)
|
|
}
|
|
|
|
func (h *Handler) AddRaffleFilter(c *fiber.Ctx) error {
|
|
var filter domain.RaffleFilter
|
|
|
|
if err := c.BodyParser(&filter); err != nil {
|
|
h.mongoLoggerSvc.Info("Failed to parse raffle filter request",
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, "Invalid request body")
|
|
}
|
|
|
|
if valErrs, ok := h.validator.Validate(c, filter); !ok {
|
|
var errMsg string
|
|
for field, msg := range valErrs {
|
|
errMsg += fmt.Sprintf("%s: %s; ", field, msg)
|
|
}
|
|
h.mongoLoggerSvc.Info("Failed to validate raffle filter",
|
|
zap.String("errMsg", errMsg),
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, errMsg)
|
|
}
|
|
|
|
switch filter.Type {
|
|
case "sport":
|
|
err := h.raffleSvc.AddSportRaffleFilter(c.Context(), filter.RaffleID, int64(filter.SportID), int64(filter.LeagueID))
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Error("Failed to add raffle filter",
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to add raffle filter")
|
|
}
|
|
|
|
// handle game case below
|
|
// there won't be a default case since its being handled in the validator
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Raffle filter added successfully", nil, nil)
|
|
}
|
|
|
|
func (h *Handler) DeleteRaffle(c *fiber.Ctx) error {
|
|
stringRaffleID := c.Params("id")
|
|
raffleID, err := strconv.Atoi(stringRaffleID)
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Info("failed to parse raffle id",
|
|
zap.String("stringRaffleID", stringRaffleID),
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, "Invalid raffle id")
|
|
}
|
|
|
|
raffle, err := h.raffleSvc.DeleteRaffle(c.Context(), int32(raffleID))
|
|
if err != nil {
|
|
fmt.Println("raffle delete error: ", err)
|
|
h.mongoLoggerSvc.Error("Failed to delete raffle",
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to delete raffle")
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Raffle deleted successfully", raffle, nil)
|
|
}
|
|
|
|
func (h *Handler) GetRafflesOfCompany(c *fiber.Ctx) error {
|
|
stringCompanyID := c.Params("id")
|
|
companyID, err := strconv.Atoi(stringCompanyID)
|
|
if err != nil || companyID == 0 {
|
|
h.mongoLoggerSvc.Info("failed to parse company id",
|
|
zap.String("stringCompanyID", stringCompanyID),
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, "Invalid company ID")
|
|
}
|
|
|
|
companyRaffles, err := h.raffleSvc.GetRafflesOfCompany(c.Context(), int32(companyID))
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Error("Failed to fetch company raffle",
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch company raffle")
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Company Raffles fetched successfully", companyRaffles, nil)
|
|
}
|
|
|
|
func (h *Handler) GetTenantRaffles(c *fiber.Ctx) error {
|
|
companyID := c.Locals("company_id").(domain.ValidInt64)
|
|
if !companyID.Valid {
|
|
h.BadRequestLogger().Error("invalid company id")
|
|
return fiber.NewError(fiber.StatusBadRequest, "invalid company id")
|
|
}
|
|
|
|
companyRaffles, err := h.raffleSvc.GetRafflesOfCompany(c.Context(), int32(companyID.Value))
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Error("Failed to fetch company raffle",
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch company raffle")
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Company Raffles fetched successfully", companyRaffles, nil)
|
|
}
|
|
|
|
func (h *Handler) GetRaffleStanding(c *fiber.Ctx) error {
|
|
raffleIDStr := c.Params("id")
|
|
limitStr := c.Params("limit")
|
|
|
|
// if error happens while parsing, it just uses zero values
|
|
// resulting in empty standing
|
|
raffleID, _ := strconv.Atoi(raffleIDStr)
|
|
limit, _ := strconv.Atoi(limitStr)
|
|
|
|
raffleStanding, err := h.raffleSvc.GetRaffleStanding(c.Context(), int32(raffleID), int32(limit))
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Error("Failed to fetch raffle standing",
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch raffle standing")
|
|
}
|
|
|
|
maskedRaffleStanding := make([]domain.RaffleStandingRes, 0, len(raffleStanding))
|
|
|
|
for _, standing := range raffleStanding {
|
|
maskedStanding := domain.RaffleStandingRes{
|
|
UserID: standing.UserID,
|
|
RaffleID: standing.RaffleID,
|
|
FirstName: standing.FirstName,
|
|
LastName: standing.LastName,
|
|
PhoneNumber: helpers.MaskPhone(standing.PhoneNumber),
|
|
Email: helpers.MaskEmail(standing.Email),
|
|
TicketCount: standing.TicketCount,
|
|
}
|
|
|
|
maskedRaffleStanding = append(maskedRaffleStanding, maskedStanding)
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Raffles standing fetched successfully", maskedRaffleStanding, nil)
|
|
}
|
|
|
|
func (h *Handler) GetRaffleWinners(c *fiber.Ctx) error {
|
|
raffleIDStr := c.Params("id")
|
|
limitStr := c.Params("limit")
|
|
|
|
// if error happens while parsing, it just uses zero values
|
|
// resulting in empty standing
|
|
raffleID, _ := strconv.Atoi(raffleIDStr)
|
|
limit, _ := strconv.Atoi(limitStr)
|
|
|
|
raffleStanding, err := h.raffleSvc.GetRaffleStanding(c.Context(), int32(raffleID), int32(limit))
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Error("Failed to fetch raffle standing",
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch raffle standing")
|
|
}
|
|
|
|
// set raffle as complete
|
|
if err := h.raffleSvc.SetRaffleComplete(c.Context(), int32(raffleID)); err != nil {
|
|
h.mongoLoggerSvc.Error("Failed to set raffle complete",
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to set raffle complete")
|
|
}
|
|
|
|
// add winners to table
|
|
var errs []error
|
|
for i, standing := range raffleStanding {
|
|
err = h.raffleSvc.CreateRaffleWinner(c.Context(), domain.RaffleWinnerParams{
|
|
RaffleID: standing.RaffleID,
|
|
UserID: int32(standing.UserID),
|
|
Rank: int32(i + 1),
|
|
})
|
|
|
|
if err != nil {
|
|
errs = append(errs, err)
|
|
}
|
|
}
|
|
|
|
if len(errs) != 0 {
|
|
h.mongoLoggerSvc.Error("Failed to create raffle winners",
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(errors.Join(errs...)),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to create raffle winners")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (h *Handler) CreateRaffleTicket(c *fiber.Ctx) error {
|
|
var req domain.CreateRaffleTicket
|
|
if err := c.BodyParser(&req); err != nil {
|
|
fmt.Println("parser error: ", err)
|
|
h.mongoLoggerSvc.Info("Failed to parse raffle ticket request",
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, "Invalid request body")
|
|
}
|
|
|
|
if valErrs, ok := h.validator.Validate(c, req); !ok {
|
|
var errMsg string
|
|
for field, msg := range valErrs {
|
|
errMsg += fmt.Sprintf("%s: %s; ", field, msg)
|
|
}
|
|
h.mongoLoggerSvc.Info("Failed to validate settings",
|
|
zap.String("errMsg", errMsg),
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, errMsg)
|
|
}
|
|
|
|
raffleTicket, err := h.raffleSvc.CreateRaffleTicket(c.Context(), req)
|
|
if err != nil {
|
|
fmt.Println("raffle ticket create error: ", err)
|
|
h.mongoLoggerSvc.Error("Failed to create raffle ticket",
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to create raffle ticket")
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "Raffle created successfully", raffleTicket, nil)
|
|
}
|
|
|
|
func (h *Handler) GetUserRaffleTickets(c *fiber.Ctx) error {
|
|
stringUserID := c.Params("id")
|
|
userID, err := strconv.Atoi(stringUserID)
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Info("failed to parse company id",
|
|
zap.String("stringUserID", stringUserID),
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, "Invalid user ID")
|
|
}
|
|
|
|
raffleTickets, err := h.raffleSvc.GetUserRaffleTickets(c.Context(), int32(userID))
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Error("Failed to fetch user raffle tickets",
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch user raffle tickets")
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "User raffle tickets fetched successfully", raffleTickets, nil)
|
|
}
|
|
|
|
func (h *Handler) SuspendRaffleTicket(c *fiber.Ctx) error {
|
|
stringRaffleTicketID := c.Params("id")
|
|
raffleTicketID, err := strconv.Atoi(stringRaffleTicketID)
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Info("failed to parse raffle ticket id",
|
|
zap.String("stringUserID", stringRaffleTicketID),
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, "Invalid raffel ticket id")
|
|
}
|
|
|
|
if err := h.raffleSvc.SuspendRaffleTicket(c.Context(), int32(raffleTicketID)); err != nil {
|
|
h.mongoLoggerSvc.Error("Failed to suspend raffle ticket",
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to suspend raffle ticket")
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "User raffle tickets suspended successfully", nil, nil)
|
|
}
|
|
|
|
func (h *Handler) UnSuspendRaffleTicket(c *fiber.Ctx) error {
|
|
stringRaffleTicketID := c.Params("id")
|
|
raffleTicketID, err := strconv.Atoi(stringRaffleTicketID)
|
|
if err != nil {
|
|
h.mongoLoggerSvc.Info("failed to parse raffle ticket id",
|
|
zap.String("stringUserID", stringRaffleTicketID),
|
|
zap.Int("status_code", fiber.StatusBadRequest),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusBadRequest, "Invalid raffel ticket id")
|
|
}
|
|
|
|
if err := h.raffleSvc.UnSuspendRaffleTicket(c.Context(), int32(raffleTicketID)); err != nil {
|
|
h.mongoLoggerSvc.Error("Failed to unsuspend raffle ticket",
|
|
zap.Int("status_code", fiber.StatusInternalServerError),
|
|
zap.Error(err),
|
|
zap.Time("timestamp", time.Now()),
|
|
)
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to unsuspend raffle ticket")
|
|
}
|
|
|
|
return response.WriteJSON(c, fiber.StatusOK, "User raffle tickets unsuspended successfully", nil, nil)
|
|
|
|
}
|