Yimaru-BackEnd/internal/repository/raffel.go

package repository

import (
	"context"

	dbgen "github.com/SamuelTariku/FortuneBet-Backend/gen/db"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
	"github.com/jackc/pgx/v5/pgtype"
)

func convertRaffleOutcome(raffle dbgen.Raffle) domain.Raffle {
	return domain.Raffle{
		ID:        raffle.ID,
		CompanyID: raffle.CompanyID,
		Name:      raffle.Name,
		CreatedAt: raffle.CreatedAt.Time,
		ExpiresAt: raffle.ExpiresAt.Time,
		Type:      raffle.Type,
		Status:    raffle.Status,
	}
}

func convertRaffleTicketOutcome(raffle dbgen.RaffleTicket) domain.RaffleTicket {
	return domain.RaffleTicket{
		ID:       raffle.ID,
		RaffleID: raffle.RaffleID,
		UserID:   raffle.UserID,
		IsActive: raffle.IsActive.Bool,
	}
}

func convertJoinedRaffleTicketOutcome(raffle dbgen.GetUserRaffleTicketsRow) domain.RaffleTicketRes {
	return domain.RaffleTicketRes{
		TicketID:  raffle.TicketID,
		UserID:    raffle.UserID,
		Name:      raffle.Name,
		Type:      raffle.Type,
		ExpiresAt: raffle.ExpiresAt.Time,
		Status:    raffle.Status,
	}
}

func convertCreateRaffle(raffle domain.CreateRaffle) dbgen.CreateRaffleParams {
	return dbgen.CreateRaffleParams{
		CompanyID: raffle.CompanyID,
		Name:      raffle.Name,
		ExpiresAt: pgtype.Timestamp{
			Time:  *raffle.ExpiresAt,
			Valid: true,
		},
		Type: raffle.Type,
	}
}

func convertRaffleStanding(raffleStanding dbgen.GetRaffleStandingRow) domain.RaffleStanding {
	return domain.RaffleStanding{
		UserID:      raffleStanding.UserID,
		RaffleID:    raffleStanding.RaffleID,
		FirstName:   raffleStanding.FirstName,
		LastName:    raffleStanding.LastName,
		PhoneNumber: raffleStanding.PhoneNumber.String,
		Email:       raffleStanding.Email.String,
		TicketCount: raffleStanding.TicketCount,
	}
}

func (s *Store) CreateRaffle(ctx context.Context, raffle domain.CreateRaffle) (domain.Raffle, error) {
	raffleRes, err := s.queries.CreateRaffle(ctx, convertCreateRaffle(raffle))
	if err != nil {
		return domain.Raffle{}, err
	}

	return convertRaffleOutcome(raffleRes), nil
}

func (s *Store) DeleteRaffle(ctx context.Context, raffleID int32) (domain.Raffle, error) {
	raffleRes, err := s.queries.DeleteRaffle(ctx, raffleID)
	if err != nil {
		return domain.Raffle{}, err
	}

	return convertRaffleOutcome(raffleRes), nil
}

func (s *Store) GetRafflesOfCompany(ctx context.Context, companyID int32) ([]dbgen.Raffle, error) {
	raffles, err := s.queries.GetRafflesOfCompany(ctx, companyID)
	if err != nil {
		return nil, err
	}

	return raffles, nil
}

func (s *Store) CreateRaffleTicket(ctx context.Context, raffleTicketParams domain.CreateRaffleTicket) (domain.RaffleTicket, error) {
	raffleTicket, err := s.queries.CreateRaffleTicket(ctx, dbgen.CreateRaffleTicketParams{
		RaffleID: raffleTicketParams.RaffleID,
		UserID:   raffleTicketParams.UserID,
	})
	if err != nil {
		return domain.RaffleTicket{}, err
	}

	return convertRaffleTicketOutcome(raffleTicket), nil
}

func (s *Store) GetUserRaffleTickets(ctx context.Context, userID int32) ([]domain.RaffleTicketRes, error) {
	raffleTickets, err := s.queries.GetUserRaffleTickets(ctx, userID)
	if err != nil {
		return nil, err
	}

	res := []domain.RaffleTicketRes{}
	for _, raffle := range raffleTickets {
		res = append(res, convertJoinedRaffleTicketOutcome(raffle))
	}

	return res, nil
}

func (s *Store) SuspendRaffleTicket(ctx context.Context, raffleTicketID int32) error {
	return s.queries.UpdateRaffleTicketStatus(ctx, dbgen.UpdateRaffleTicketStatusParams{
		ID: raffleTicketID,
		IsActive: pgtype.Bool{
			Bool:  false,
			Valid: true,
		},
	})
}

func (s *Store) UnSuspendRaffleTicket(ctx context.Context, raffleID int32) error {
	return s.queries.UpdateRaffleTicketStatus(ctx, dbgen.UpdateRaffleTicketStatusParams{
		ID: raffleID,
		IsActive: pgtype.Bool{
			Bool:  true,
			Valid: true,
		},
	})
}

// TODO: could also add -> suspend a specific user's raffle tickets

func (s *Store) GetRaffleStanding(ctx context.Context, raffleID, limit int32) ([]domain.RaffleStanding, error) {
	raffleStanding, err := s.queries.GetRaffleStanding(ctx, dbgen.GetRaffleStandingParams{
		RaffleID: raffleID,
		Limit:    limit,
	})
	if err != nil {
		return nil, err
	}

	res := []domain.RaffleStanding{}
	for _, standing := range raffleStanding {
		res = append(res, convertRaffleStanding(standing))
	}

	return res, nil
}

func (s *Store) CreateRaffleWinner(ctx context.Context, raffleWinnerParams domain.RaffleWinnerParams) error {
	_, err := s.queries.CreateRaffleWinner(ctx, dbgen.CreateRaffleWinnerParams{
		RaffleID: raffleWinnerParams.RaffleID,
		UserID:   raffleWinnerParams.UserID,
		Rank:     raffleWinnerParams.Rank,
	})

	return err
}

func (s *Store) SetRaffleComplete(ctx context.Context, raffleID int32) error {
	return s.queries.SetRaffleComplete(ctx, raffleID)
}

func (s *Store) AddSportRaffleFilter(ctx context.Context, raffleID int32, sportID, leagueID int64) error {
	_, err := s.queries.AddSportRaffleFilter(ctx, dbgen.AddSportRaffleFilterParams{
		RaffleID: raffleID,
		SportID:  sportID,
		LeagueID: leagueID,
	})
	return err
}

func (s *Store) CheckValidSportRaffleFilter(ctx context.Context, raffleID int32, sportID, leagueID int64) (bool, error) {
	res, err := s.queries.CheckValidSportRaffleFilter(ctx, dbgen.CheckValidSportRaffleFilterParams{
		RaffleID: raffleID,
		SportID:  sportID,
		LeagueID: leagueID,
	})
	if err != nil {
		return false, err
	}

	return res, nil
}