495 lines
13 KiB
Go
495 lines
13 KiB
Go
package bet
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"log/slog"
|
|
"math/big"
|
|
random "math/rand"
|
|
"slices"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/services/branch"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/services/event"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/services/odds"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/services/wallet"
|
|
)
|
|
|
|
type Service struct {
|
|
betStore BetStore
|
|
eventSvc event.Service
|
|
prematchSvc odds.Service
|
|
walletSvc wallet.Service
|
|
branchSvc branch.Service
|
|
logger *slog.Logger
|
|
}
|
|
|
|
func NewService(betStore BetStore, eventSvc event.Service, prematchSvc odds.Service, walletSvc wallet.Service, branchSvc branch.Service, logger *slog.Logger) *Service {
|
|
return &Service{
|
|
betStore: betStore,
|
|
eventSvc: eventSvc,
|
|
prematchSvc: prematchSvc,
|
|
walletSvc: walletSvc,
|
|
branchSvc: branchSvc,
|
|
logger: logger,
|
|
}
|
|
}
|
|
|
|
var (
|
|
ErrEventHasNotEnded = errors.New("Event has not ended yet")
|
|
ErrRawOddInvalid = errors.New("Prematch Raw Odd is Invalid")
|
|
ErrBranchIDRequired = errors.New("Branch ID required for this role")
|
|
ErrOutcomeLimit = errors.New("Too many outcomes on a single bet")
|
|
)
|
|
|
|
func (s *Service) GenerateCashoutID() (string, error) {
|
|
const chars = "abcdefghijklmnopqrstuvwxyz0123456789"
|
|
const length int = 13
|
|
charLen := big.NewInt(int64(len(chars)))
|
|
result := make([]byte, length)
|
|
for i := 0; i < length; i++ {
|
|
index, err := rand.Int(rand.Reader, charLen)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
result[i] = chars[index.Int64()]
|
|
}
|
|
return string(result), nil
|
|
}
|
|
|
|
func (s *Service) GenerateBetOutcome(ctx context.Context, eventID int64, marketID int64, oddID int64) (domain.CreateBetOutcome, error) {
|
|
// TODO: Change this when you refactor the database code
|
|
eventIDStr := strconv.FormatInt(eventID, 10)
|
|
marketIDStr := strconv.FormatInt(marketID, 10)
|
|
oddIDStr := strconv.FormatInt(oddID, 10)
|
|
|
|
event, err := s.eventSvc.GetUpcomingEventByID(ctx, eventIDStr)
|
|
if err != nil {
|
|
return domain.CreateBetOutcome{}, err
|
|
}
|
|
|
|
currentTime := time.Now()
|
|
if event.StartTime.Before(currentTime) {
|
|
return domain.CreateBetOutcome{}, ErrEventHasNotEnded
|
|
}
|
|
|
|
odds, err := s.prematchSvc.GetRawOddsByMarketID(ctx, marketIDStr, eventIDStr)
|
|
|
|
if err != nil {
|
|
return domain.CreateBetOutcome{}, err
|
|
}
|
|
type rawOddType struct {
|
|
ID string
|
|
Name string
|
|
Odds string
|
|
Header string
|
|
Handicap string
|
|
}
|
|
|
|
var selectedOdd rawOddType
|
|
var isOddFound bool = false
|
|
|
|
for _, raw := range odds.RawOdds {
|
|
var rawOdd rawOddType
|
|
rawBytes, err := json.Marshal(raw)
|
|
err = json.Unmarshal(rawBytes, &rawOdd)
|
|
if err != nil {
|
|
fmt.Printf("Failed to unmarshal raw odd %v", err)
|
|
continue
|
|
}
|
|
if rawOdd.ID == oddIDStr {
|
|
selectedOdd = rawOdd
|
|
isOddFound = true
|
|
}
|
|
}
|
|
if !isOddFound {
|
|
return domain.CreateBetOutcome{}, ErrRawOddInvalid
|
|
}
|
|
|
|
parsedOdd, err := strconv.ParseFloat(selectedOdd.Odds, 32)
|
|
if err != nil {
|
|
return domain.CreateBetOutcome{}, err
|
|
}
|
|
sportID, err := strconv.ParseInt(event.SportID, 10, 64)
|
|
if err != nil {
|
|
return domain.CreateBetOutcome{}, err
|
|
}
|
|
newOutcome := domain.CreateBetOutcome{
|
|
EventID: eventID,
|
|
OddID: oddID,
|
|
MarketID: marketID,
|
|
SportID: sportID,
|
|
HomeTeamName: event.HomeTeam,
|
|
AwayTeamName: event.AwayTeam,
|
|
MarketName: odds.MarketName,
|
|
Odd: float32(parsedOdd),
|
|
OddName: selectedOdd.Name,
|
|
OddHeader: selectedOdd.Header,
|
|
OddHandicap: selectedOdd.Handicap,
|
|
Expires: event.StartTime,
|
|
}
|
|
|
|
return newOutcome, nil
|
|
|
|
}
|
|
|
|
func (s *Service) PlaceBet(ctx context.Context, req domain.CreateBetReq, userID int64, role domain.Role) (domain.CreateBetRes, error) {
|
|
// You can move the loop over req.Outcomes and all the business logic here.
|
|
|
|
if len(req.Outcomes) > 30 {
|
|
return domain.CreateBetRes{}, ErrOutcomeLimit
|
|
}
|
|
|
|
var outcomes []domain.CreateBetOutcome = make([]domain.CreateBetOutcome, 0, len(req.Outcomes))
|
|
var totalOdds float32 = 1
|
|
|
|
for _, outcomeReq := range req.Outcomes {
|
|
newOutcome, err := s.GenerateBetOutcome(ctx, outcomeReq.EventID, outcomeReq.MarketID, outcomeReq.OddID)
|
|
if err != nil {
|
|
return domain.CreateBetRes{}, err
|
|
}
|
|
totalOdds = totalOdds * float32(newOutcome.Odd)
|
|
outcomes = append(outcomes, newOutcome)
|
|
}
|
|
|
|
// Handle role-specific logic and wallet deduction if needed.
|
|
var cashoutID string
|
|
cashoutID, err := s.GenerateCashoutID()
|
|
|
|
if err != nil {
|
|
return domain.CreateBetRes{}, err
|
|
}
|
|
|
|
newBet := domain.CreateBet{
|
|
Amount: domain.ToCurrency(req.Amount),
|
|
TotalOdds: totalOdds,
|
|
Status: req.Status,
|
|
FullName: req.FullName,
|
|
PhoneNumber: req.PhoneNumber,
|
|
CashoutID: cashoutID,
|
|
}
|
|
switch role {
|
|
case domain.RoleCashier:
|
|
branch, err := s.branchSvc.GetBranchByCashier(ctx, userID)
|
|
if err != nil {
|
|
return domain.CreateBetRes{}, err
|
|
}
|
|
// Deduct from wallet:
|
|
// TODO: Make this percentage come from the company
|
|
var deductedAmount = req.Amount / 10
|
|
err = s.walletSvc.DeductFromWallet(ctx, branch.WalletID, domain.ToCurrency(deductedAmount))
|
|
|
|
if err != nil {
|
|
return domain.CreateBetRes{}, err
|
|
}
|
|
newBet.BranchID = domain.ValidInt64{
|
|
Value: branch.ID,
|
|
Valid: true,
|
|
}
|
|
newBet.UserID = domain.ValidInt64{
|
|
Value: userID,
|
|
Valid: true,
|
|
}
|
|
newBet.IsShopBet = true
|
|
// bet, err = s.betStore.CreateBet(ctx)
|
|
case domain.RoleBranchManager, domain.RoleAdmin, domain.RoleSuperAdmin:
|
|
// TODO: restrict the Branch ID of Admin and Branch Manager to only the branches within their own company
|
|
// If a non cashier wants to create a bet, they will need to provide the Branch ID
|
|
if req.BranchID == nil {
|
|
return domain.CreateBetRes{}, ErrBranchIDRequired
|
|
}
|
|
|
|
newBet.BranchID = domain.ValidInt64{
|
|
Value: *req.BranchID,
|
|
Valid: true,
|
|
}
|
|
newBet.UserID = domain.ValidInt64{
|
|
Value: userID,
|
|
Valid: true,
|
|
}
|
|
newBet.IsShopBet = true
|
|
case domain.RoleCustomer:
|
|
return domain.CreateBetRes{}, fmt.Errorf("Not yet implemented")
|
|
default:
|
|
return domain.CreateBetRes{}, fmt.Errorf("Unknown Role Type")
|
|
}
|
|
|
|
bet, err := s.CreateBet(ctx, newBet)
|
|
|
|
if err != nil {
|
|
return domain.CreateBetRes{}, err
|
|
}
|
|
|
|
// Associate outcomes with the bet.
|
|
for i := range outcomes {
|
|
outcomes[i].BetID = bet.ID
|
|
}
|
|
rows, err := s.betStore.CreateBetOutcome(ctx, outcomes)
|
|
if err != nil {
|
|
return domain.CreateBetRes{}, err
|
|
}
|
|
|
|
res := domain.ConvertCreateBet(bet, rows)
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func (s *Service) GenerateRandomBetOutcomes(ctx context.Context, eventID, sportID, HomeTeam, AwayTeam string, StartTime time.Time) ([]domain.CreateBetOutcome, float32, error) {
|
|
|
|
var newOdds []domain.CreateBetOutcome
|
|
var totalOdds float32 = 1
|
|
|
|
markets, err := s.prematchSvc.GetPrematchOdds(ctx, eventID)
|
|
|
|
if err != nil {
|
|
s.logger.Error("failed to get odds for event", "event id", eventID, "error", err)
|
|
return nil, 0, err
|
|
}
|
|
|
|
if len(markets) == 0 {
|
|
s.logger.Error("empty odds for event", "event id", eventID)
|
|
return nil, 0, fmt.Errorf("empty odds or event", "event id", eventID)
|
|
}
|
|
|
|
var numMarkets = min(5, len(markets))
|
|
var randIndex []int = make([]int, numMarkets)
|
|
for i := 0; i < numMarkets; i++ {
|
|
// Guarantee that the odd is unique
|
|
var newRandMarket int
|
|
count := 0
|
|
for {
|
|
newRandMarket = random.Intn(len(markets))
|
|
if !slices.Contains(randIndex, newRandMarket) {
|
|
break
|
|
}
|
|
// just in case
|
|
if count >= 5 {
|
|
s.logger.Warn("market overload", "event id", eventID)
|
|
break
|
|
}
|
|
count++
|
|
}
|
|
|
|
randIndex[i] = newRandMarket
|
|
|
|
rawOdds := markets[i].RawOdds
|
|
randomRawOdd := rawOdds[random.Intn(len(rawOdds))]
|
|
|
|
type rawOddType struct {
|
|
ID string
|
|
Name string
|
|
Odds string
|
|
Header string
|
|
Handicap string
|
|
}
|
|
|
|
var selectedOdd rawOddType
|
|
rawBytes, err := json.Marshal(randomRawOdd)
|
|
err = json.Unmarshal(rawBytes, &selectedOdd)
|
|
|
|
if err != nil {
|
|
fmt.Printf("Failed to unmarshal raw odd %v", err)
|
|
continue
|
|
}
|
|
parsedOdd, err := strconv.ParseFloat(selectedOdd.Odds, 32)
|
|
if err != nil {
|
|
s.logger.Error("Failed to parse odd", "error", err)
|
|
continue
|
|
}
|
|
sportID, err := strconv.ParseInt(sportID, 10, 64)
|
|
if err != nil {
|
|
s.logger.Error("Failed to get sport id", "error", err)
|
|
continue
|
|
}
|
|
eventID, err := strconv.ParseInt(eventID, 10, 64)
|
|
if err != nil {
|
|
s.logger.Error("Failed to get event id", "error", err)
|
|
continue
|
|
}
|
|
oddID, err := strconv.ParseInt(selectedOdd.ID, 10, 64)
|
|
if err != nil {
|
|
s.logger.Error("Failed to get odd id", "error", err)
|
|
continue
|
|
}
|
|
|
|
marketID, err := strconv.ParseInt(markets[i].MarketID, 10, 64)
|
|
if err != nil {
|
|
s.logger.Error("Failed to get odd id", "error", err)
|
|
continue
|
|
}
|
|
|
|
marketName := markets[i].MarketName
|
|
|
|
newOdds = append(newOdds, domain.CreateBetOutcome{
|
|
EventID: eventID,
|
|
OddID: oddID,
|
|
MarketID: marketID,
|
|
SportID: sportID,
|
|
HomeTeamName: HomeTeam,
|
|
AwayTeamName: AwayTeam,
|
|
MarketName: marketName,
|
|
Odd: float32(parsedOdd),
|
|
OddName: selectedOdd.Name,
|
|
OddHeader: selectedOdd.Header,
|
|
OddHandicap: selectedOdd.Handicap,
|
|
Expires: StartTime,
|
|
})
|
|
|
|
totalOdds = totalOdds * float32(parsedOdd)
|
|
|
|
}
|
|
|
|
if len(newOdds) == 0 {
|
|
s.logger.Error("Failed to generate random outcomes")
|
|
return nil, 0, nil
|
|
}
|
|
|
|
return newOdds, totalOdds, nil
|
|
}
|
|
|
|
func (s *Service) PlaceRandomBet(ctx context.Context, userID, branchID int64) (domain.CreateBetRes, error) {
|
|
|
|
// Get a unexpired event id
|
|
events, _, err := s.eventSvc.GetPaginatedUpcomingEvents(ctx, 5, 0, domain.ValidString{}, domain.ValidString{})
|
|
|
|
if err != nil {
|
|
return domain.CreateBetRes{}, err
|
|
}
|
|
|
|
// Get market and odds for that
|
|
var randomOdds []domain.CreateBetOutcome
|
|
var totalOdds float32 = 1
|
|
for _, event := range events {
|
|
|
|
newOdds, total, err := s.GenerateRandomBetOutcomes(ctx, event.ID, event.SportID, event.HomeTeam, event.AwayTeam, event.StartTime)
|
|
|
|
if err != nil {
|
|
s.logger.Error("failed to generate random bet outcome", "event id", event.ID, "error", err)
|
|
continue
|
|
}
|
|
|
|
randomOdds = append(randomOdds, newOdds...)
|
|
totalOdds = totalOdds * total
|
|
|
|
}
|
|
if len(randomOdds) == 0 {
|
|
s.logger.Error("Failed to generate random outcomes")
|
|
return domain.CreateBetRes{}, nil
|
|
}
|
|
|
|
var cashoutID string
|
|
|
|
cashoutID, err = s.GenerateCashoutID()
|
|
if err != nil {
|
|
return domain.CreateBetRes{}, err
|
|
}
|
|
|
|
randomNumber := strconv.FormatInt(int64(random.Intn(10)), 10)
|
|
newBet := domain.CreateBet{
|
|
Amount: 123,
|
|
TotalOdds: totalOdds,
|
|
Status: domain.OUTCOME_STATUS_PENDING,
|
|
FullName: "test" + randomNumber,
|
|
PhoneNumber: randomNumber,
|
|
CashoutID: cashoutID,
|
|
BranchID: domain.ValidInt64{Valid: true, Value: branchID},
|
|
UserID: domain.ValidInt64{Valid: true, Value: userID},
|
|
}
|
|
|
|
bet, err := s.CreateBet(ctx, newBet)
|
|
if err != nil {
|
|
return domain.CreateBetRes{}, err
|
|
}
|
|
|
|
for i := range randomOdds {
|
|
randomOdds[i].BetID = bet.ID
|
|
}
|
|
|
|
rows, err := s.betStore.CreateBetOutcome(ctx, randomOdds)
|
|
if err != nil {
|
|
return domain.CreateBetRes{}, err
|
|
}
|
|
|
|
res := domain.ConvertCreateBet(bet, rows)
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func (s *Service) CreateBet(ctx context.Context, bet domain.CreateBet) (domain.Bet, error) {
|
|
return s.betStore.CreateBet(ctx, bet)
|
|
}
|
|
|
|
func (s *Service) CreateBetOutcome(ctx context.Context, outcomes []domain.CreateBetOutcome) (int64, error) {
|
|
return s.betStore.CreateBetOutcome(ctx, outcomes)
|
|
}
|
|
|
|
func (s *Service) GetBetByID(ctx context.Context, id int64) (domain.GetBet, error) {
|
|
return s.betStore.GetBetByID(ctx, id)
|
|
}
|
|
func (s *Service) GetBetByCashoutID(ctx context.Context, id string) (domain.GetBet, error) {
|
|
return s.betStore.GetBetByCashoutID(ctx, id)
|
|
}
|
|
func (s *Service) GetAllBets(ctx context.Context) ([]domain.GetBet, error) {
|
|
return s.betStore.GetAllBets(ctx)
|
|
}
|
|
|
|
func (s *Service) GetBetByBranchID(ctx context.Context, branchID int64) ([]domain.GetBet, error) {
|
|
return s.betStore.GetBetByBranchID(ctx, branchID)
|
|
}
|
|
|
|
func (s *Service) UpdateCashOut(ctx context.Context, id int64, cashedOut bool) error {
|
|
return s.betStore.UpdateCashOut(ctx, id, cashedOut)
|
|
}
|
|
|
|
func (s *Service) UpdateStatus(ctx context.Context, id int64, status domain.OutcomeStatus) error {
|
|
return s.betStore.UpdateStatus(ctx, id, status)
|
|
}
|
|
|
|
func (s *Service) checkBetOutcomeForBet(ctx context.Context, eventID int64) error {
|
|
betOutcomes, err := s.betStore.GetBetOutcomeByEventID(ctx, eventID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
status := domain.OUTCOME_STATUS_PENDING
|
|
|
|
for _, betOutcome := range betOutcomes {
|
|
// Check if any of them are pending
|
|
if betOutcome.Status == domain.OUTCOME_STATUS_PENDING {
|
|
return nil
|
|
}
|
|
|
|
if status == domain.OUTCOME_STATUS_PENDING {
|
|
status = betOutcome.Status
|
|
} else if status == domain.OUTCOME_STATUS_WIN {
|
|
status = betOutcome.Status
|
|
} else if status == domain.OUTCOME_STATUS_LOSS {
|
|
continue
|
|
}
|
|
}
|
|
|
|
if status != domain.OUTCOME_STATUS_PENDING {
|
|
return nil
|
|
}
|
|
|
|
return s.UpdateStatus(ctx, eventID, status)
|
|
|
|
}
|
|
|
|
func (s *Service) UpdateBetOutcomeStatus(ctx context.Context, id int64, status domain.OutcomeStatus) error {
|
|
betOutcome, err := s.betStore.UpdateBetOutcomeStatus(ctx, id, status)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.checkBetOutcomeForBet(ctx, betOutcome.EventID)
|
|
|
|
}
|
|
|
|
func (s *Service) DeleteBet(ctx context.Context, id int64) error {
|
|
return s.betStore.DeleteBet(ctx, id)
|
|
}
|