Yimaru/Yimaru-BackEnd
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

unit test bet outcome

Browse Source
This commit is contained in:
Yared Yemane 2025-05-28 22:18:27 +03:00
parent c637ddb321
commit 95eaed18ad
8 changed files with 489 additions and 440 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
docs/docs.go
View File

@ -4177,7 +4177,7 @@ const docTemplate = `{
"application/json"
],
"tags": [
"Virtual Games"
"Veli Games"
],
"summary": "Veli Games webhook handler",
"parameters": [

2
docs/swagger.json
View File

@ -4169,7 +4169,7 @@
"application/json"
],
"tags": [
"Virtual Games"
"Veli Games"
],
"summary": "Veli Games webhook handler",
"parameters": [

2
docs/swagger.yaml
View File

@ -4258,7 +4258,7 @@ paths:
type: object
summary: Veli Games webhook handler
tags:
- Virtual Games
- Veli Games
securityDefinitions:
Bearer:
in: header

864
internal/services/result/eval.go
View File

@ -498,491 +498,491 @@ func evaluateTotalOverUnder(outcome domain.BetOutcome, score struct{ Home, Away
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid odd header: %s", outcome.OddHeader)
}
// Result and Total betting is a type of bet where the bettor predicts
// the outcome of a match and whether the total number of points scored will be over or under a specified number.
func evaluateResultAndTotal(outcome domain.BetOutcome, score struct{ Home, Away int }) (domain.OutcomeStatus, error) {
// Result and Total betting is a type of bet where the bettor predicts
// the outcome of a match and whether the total number of points scored will be over or under a specified number.
func evaluateResultAndTotal(outcome domain.BetOutcome, score struct{ Home, Away int }) (domain.OutcomeStatus, error) {
// The handicap will be in the format "U {float}" or "O {float}"
// U and O denoting over and under for this case
overUnderStr := strings.Split(outcome.OddHandicap, " ")
if len(overUnderStr) != 2 {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid threshold: %s", outcome.OddName)
}
overUnder := overUnderStr[0]
if overUnder != "Over" && overUnder != "Under" {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("failed parsing over under: %s", outcome.OddHeader)
}
threshold, err := strconv.ParseFloat(overUnderStr[1], 64)
if err != nil {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid threshold: %s", outcome.OddName)
}
// Since the threshold will come in a xx.5 format, there is no VOID for this kind of bet
totalScore := float64(score.Home + score.Away)
switch outcome.OddHeader {
case "1":
if score.Home < score.Away {
return domain.OUTCOME_STATUS_LOSS, nil
// The handicap will be in the format "U {float}" or "O {float}"
// U and O denoting over and under for this case
overUnderStr := strings.Split(outcome.OddHandicap, " ")
if len(overUnderStr) != 2 {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid threshold: %s", outcome.OddName)
}
if overUnder == "Over" && totalScore > threshold {
return domain.OUTCOME_STATUS_WIN, nil
} else if overUnder == "Under" && totalScore < threshold {
return domain.OUTCOME_STATUS_WIN, nil
overUnder := overUnderStr[0]
if overUnder != "Over" && overUnder != "Under" {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("failed parsing over under: %s", outcome.OddHeader)
}
return domain.OUTCOME_STATUS_LOSS, nil
case "2":
if score.Away < score.Home {
return domain.OUTCOME_STATUS_LOSS, nil
}
if overUnder == "Over" && totalScore > threshold {
return domain.OUTCOME_STATUS_WIN, nil
} else if overUnder == "Under" && totalScore < threshold {
return domain.OUTCOME_STATUS_WIN, nil
threshold, err := strconv.ParseFloat(overUnderStr[1], 64)
if err != nil {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid threshold: %s", outcome.OddName)
}
return domain.OUTCOME_STATUS_LOSS, nil
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("failed to parse over and under: %s", outcome.OddName)
}
}
// Since the threshold will come in a xx.5 format, there is no VOID for this kind of bet
totalScore := float64(score.Home + score.Away)
// Team Total betting is a type of bet where the bettor predicts the total number of points scored by a specific team in a match
// is over or under a specified number.
func evaluateTeamTotal(outcome domain.BetOutcome, score struct{ Home, Away int }) (domain.OutcomeStatus, error) {
switch outcome.OddHeader {
case "1":
if score.Home < score.Away {
return domain.OUTCOME_STATUS_LOSS, nil
}
// The handicap will be in the format "U {float}" or "O {float}"
// U and O denoting over and under for this case
overUnderStr := strings.Split(outcome.OddHandicap, " ")
if len(overUnderStr) != 2 {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid threshold: %s", outcome.OddHandicap)
}
overUnder := overUnderStr[0]
if overUnder != "Over" && overUnder != "Under" {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("failed parsing over under: %s", outcome.OddHeader)
}
threshold, err := strconv.ParseFloat(overUnderStr[1], 64)
if err != nil {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid threshold: %s", outcome.OddHandicap)
}
// Since the threshold will come in a xx.5 format, there is no VOID for this kind of bet
HomeScore := float64(score.Home)
AwayScore := float64(score.Away)
switch outcome.OddHeader {
case "1":
if overUnder == "Over" && HomeScore > threshold {
return domain.OUTCOME_STATUS_WIN, nil
} else if overUnder == "Under" && HomeScore < threshold {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
case "2":
if overUnder == "Over" && AwayScore > threshold {
return domain.OUTCOME_STATUS_WIN, nil
} else if overUnder == "Under" && AwayScore < threshold {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("failed to parse over and under: %s", outcome.OddName)
}
}
// Result and Both Teams To Score X Points is a type of bet where the bettor predicts whether both teams will score a certain number of points
// and also the result fo the match
func evaluateResultAndBTTSX(outcome domain.BetOutcome, score struct{ Home, Away int }) (domain.OutcomeStatus, error) {
// The name parameter will hold value "name": "{team_name} and {Yes | No}"
// The best way to do this is to evaluate backwards since there might be
// teams with 'and' in their name
// We know that there is going to be "Yes" and "No "
oddNameSplit := strings.Split(outcome.OddName, " ")
scoreCheckSplit := oddNameSplit[len(oddNameSplit)-1]
var isScorePoints bool
if scoreCheckSplit == "Yes" {
isScorePoints = true
} else if scoreCheckSplit == "No" {
isScorePoints = false
} else {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid odd name: %s", outcome.OddName)
}
teamName := strings.TrimSpace(strings.Join(oddNameSplit[:len(oddNameSplit)-2], ""))
threshold, err := strconv.ParseInt(outcome.OddHeader, 10, 64)
if err != nil {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid threshold: %s", outcome.OddHeader)
}
switch teamName {
case outcome.HomeTeamName:
if score.Home > score.Away {
if isScorePoints && score.Home >= int(threshold) && score.Away >= int(threshold) {
if overUnder == "Over" && totalScore > threshold {
return domain.OUTCOME_STATUS_WIN, nil
} else if !isScorePoints && score.Home < int(threshold) && score.Away < int(threshold) {
} else if overUnder == "Under" && totalScore < threshold {
return domain.OUTCOME_STATUS_WIN, nil
}
}
case outcome.AwayTeamName:
if score.Away > score.Home {
if isScorePoints && score.Home >= int(threshold) && score.Away >= int(threshold) {
return domain.OUTCOME_STATUS_LOSS, nil
case "2":
if score.Away < score.Home {
return domain.OUTCOME_STATUS_LOSS, nil
}
if overUnder == "Over" && totalScore > threshold {
return domain.OUTCOME_STATUS_WIN, nil
} else if !isScorePoints && score.Home < int(threshold) && score.Away < int(threshold) {
} else if overUnder == "Under" && totalScore < threshold {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("failed to parse over and under: %s", outcome.OddName)
}
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("team name error: %s", teamName)
}
return domain.OUTCOME_STATUS_LOSS, nil
// Team Total betting is a type of bet where the bettor predicts the total number of points scored by a specific team in a match
// is over or under a specified number.
func evaluateTeamTotal(outcome domain.BetOutcome, score struct{ Home, Away int }) (domain.OutcomeStatus, error) {
}
// The handicap will be in the format "U {float}" or "O {float}"
// U and O denoting over and under for this case
overUnderStr := strings.Split(outcome.OddHandicap, " ")
if len(overUnderStr) != 2 {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid threshold: %s", outcome.OddHandicap)
}
// Both Teams To Score X Points is a type of bet where the bettor predicts whether both teams will score a certain number of points.
func evaluateBTTSX(outcome domain.BetOutcome, score struct{ Home, Away int }) (domain.OutcomeStatus, error) {
threshold, err := strconv.ParseInt(outcome.OddName, 10, 64)
if err != nil {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid threshold: %s", outcome.OddName)
overUnder := overUnderStr[0]
if overUnder != "Over" && overUnder != "Under" {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("failed parsing over under: %s", outcome.OddHeader)
}
threshold, err := strconv.ParseFloat(overUnderStr[1], 64)
if err != nil {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid threshold: %s", outcome.OddHandicap)
}
// Since the threshold will come in a xx.5 format, there is no VOID for this kind of bet
HomeScore := float64(score.Home)
AwayScore := float64(score.Away)
switch outcome.OddHeader {
case "1":
if overUnder == "Over" && HomeScore > threshold {
return domain.OUTCOME_STATUS_WIN, nil
} else if overUnder == "Under" && HomeScore < threshold {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
case "2":
if overUnder == "Over" && AwayScore > threshold {
return domain.OUTCOME_STATUS_WIN, nil
} else if overUnder == "Under" && AwayScore < threshold {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("failed to parse over and under: %s", outcome.OddName)
}
}
switch outcome.OddHeader {
case "Yes":
if score.Home >= int(threshold) && score.Away >= int(threshold) {
return domain.OUTCOME_STATUS_WIN, nil
}
case "No":
if score.Home < int(threshold) && score.Away < int(threshold) {
return domain.OUTCOME_STATUS_WIN, nil
// Result and Both Teams To Score X Points is a type of bet where the bettor predicts whether both teams will score a certain number of points
// and also the result fo the match
func evaluateResultAndBTTSX(outcome domain.BetOutcome, score struct{ Home, Away int }) (domain.OutcomeStatus, error) {
// The name parameter will hold value "name": "{team_name} and {Yes | No}"
// The best way to do this is to evaluate backwards since there might be
// teams with 'and' in their name
// We know that there is going to be "Yes" and "No "
oddNameSplit := strings.Split(outcome.OddName, " ")
scoreCheckSplit := oddNameSplit[len(oddNameSplit)-1]
var isScorePoints bool
if scoreCheckSplit == "Yes" {
isScorePoints = true
} else if scoreCheckSplit == "No" {
isScorePoints = false
} else {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid odd name: %s", outcome.OddName)
}
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid odd header: %s", outcome.OddHeader)
}
teamName := strings.TrimSpace(strings.Join(oddNameSplit[:len(oddNameSplit)-2], ""))
return domain.OUTCOME_STATUS_LOSS, nil
}
// Money Line 3 Way betting is a type of bet where the bettor predicts the outcome of a match with three possible outcomes: home win, away win, or draw.
func evaluateMoneyLine3Way(outcome domain.BetOutcome, score struct{ Home, Away int }) (domain.OutcomeStatus, error) {
switch outcome.OddName {
case "1": // Home win
if score.Home > score.Away {
return domain.OUTCOME_STATUS_WIN, nil
threshold, err := strconv.ParseInt(outcome.OddHeader, 10, 64)
if err != nil {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid threshold: %s", outcome.OddHeader)
}
switch teamName {
case outcome.HomeTeamName:
if score.Home > score.Away {
if isScorePoints && score.Home >= int(threshold) && score.Away >= int(threshold) {
return domain.OUTCOME_STATUS_WIN, nil
} else if !isScorePoints && score.Home < int(threshold) && score.Away < int(threshold) {
return domain.OUTCOME_STATUS_WIN, nil
}
}
case outcome.AwayTeamName:
if score.Away > score.Home {
if isScorePoints && score.Home >= int(threshold) && score.Away >= int(threshold) {
return domain.OUTCOME_STATUS_WIN, nil
} else if !isScorePoints && score.Home < int(threshold) && score.Away < int(threshold) {
return domain.OUTCOME_STATUS_WIN, nil
}
}
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("team name error: %s", teamName)
}
return domain.OUTCOME_STATUS_LOSS, nil
case "Tie":
if score.Home == score.Away {
return domain.OUTCOME_STATUS_WIN, nil
}
// Both Teams To Score X Points is a type of bet where the bettor predicts whether both teams will score a certain number of points.
func evaluateBTTSX(outcome domain.BetOutcome, score struct{ Home, Away int }) (domain.OutcomeStatus, error) {
threshold, err := strconv.ParseInt(outcome.OddName, 10, 64)
if err != nil {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid threshold: %s", outcome.OddName)
}
return domain.OUTCOME_STATUS_LOSS, nil
case "2": // Away win
if score.Away > score.Home {
return domain.OUTCOME_STATUS_WIN, nil
switch outcome.OddHeader {
case "Yes":
if score.Home >= int(threshold) && score.Away >= int(threshold) {
return domain.OUTCOME_STATUS_WIN, nil
}
case "No":
if score.Home < int(threshold) && score.Away < int(threshold) {
return domain.OUTCOME_STATUS_WIN, nil
}
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid odd header: %s", outcome.OddHeader)
}
return domain.OUTCOME_STATUS_LOSS, nil
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid odd name: %s", outcome.OddName)
}
}
// Double Result betting is a type of bet where the bettor predicts the outcome of a match at both half-time and full-time.
func evaluateDoubleResult(outcome domain.BetOutcome, firstHalfScore struct{ Home, Away int }, secondHalfScore struct{ Home, Away int }) (domain.OutcomeStatus, error) {
halfWins := strings.Split(outcome.OddName, "-")
if len(halfWins) != 2 {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid odd name: %s", outcome.OddName)
}
firstHalfWinner := strings.TrimSpace(halfWins[0])
secondHalfWinner := strings.TrimSpace(halfWins[1])
if firstHalfWinner != outcome.HomeTeamName && firstHalfWinner != outcome.AwayTeamName && firstHalfWinner != "Tie" {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", firstHalfWinner)
}
if secondHalfWinner != outcome.HomeTeamName && secondHalfWinner != outcome.AwayTeamName && secondHalfWinner != "Tie" {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", firstHalfWinner)
}
switch {
case firstHalfWinner == outcome.HomeTeamName && firstHalfScore.Home < firstHalfScore.Away:
return domain.OUTCOME_STATUS_LOSS, nil
case firstHalfWinner == outcome.AwayTeamName && firstHalfScore.Away < firstHalfScore.Home:
return domain.OUTCOME_STATUS_LOSS, nil
case firstHalfWinner == "Tie" && firstHalfScore.Home != firstHalfScore.Away:
return domain.OUTCOME_STATUS_LOSS, nil
}
switch {
case secondHalfWinner == outcome.HomeTeamName && firstHalfScore.Home < firstHalfScore.Away:
return domain.OUTCOME_STATUS_LOSS, nil
case secondHalfWinner == outcome.AwayTeamName && firstHalfScore.Away < firstHalfScore.Home:
return domain.OUTCOME_STATUS_LOSS, nil
case secondHalfWinner == "Tie" && firstHalfScore.Home != firstHalfScore.Away:
return domain.OUTCOME_STATUS_LOSS, nil
// Money Line 3 Way betting is a type of bet where the bettor predicts the outcome of a match with three possible outcomes: home win, away win, or draw.
func evaluateMoneyLine3Way(outcome domain.BetOutcome, score struct{ Home, Away int }) (domain.OutcomeStatus, error) {
switch outcome.OddName {
case "1": // Home win
if score.Home > score.Away {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
case "Tie":
if score.Home == score.Away {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
case "2": // Away win
if score.Away > score.Home {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid odd name: %s", outcome.OddName)
}
}
return domain.OUTCOME_STATUS_WIN, nil
}
// Double Result betting is a type of bet where the bettor predicts the outcome of a match at both half-time and full-time.
func evaluateDoubleResult(outcome domain.BetOutcome, firstHalfScore struct{ Home, Away int }, secondHalfScore struct{ Home, Away int }) (domain.OutcomeStatus, error) {
halfWins := strings.Split(outcome.OddName, "-")
if len(halfWins) != 2 {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid odd name: %s", outcome.OddName)
}
firstHalfWinner := strings.TrimSpace(halfWins[0])
secondHalfWinner := strings.TrimSpace(halfWins[1])
// Highest Scoring Half betting is a type of bet where the bettor predicts which half of the match will have the highest total score.
func evaluateHighestScoringHalf(outcome domain.BetOutcome, firstScore struct{ Home, Away int }, secondScore struct{ Home, Away int }) (domain.OutcomeStatus, error) {
firstHalfTotal := firstScore.Home + firstScore.Away
secondHalfTotal := secondScore.Home + secondScore.Away
switch outcome.OddName {
case "1st Half":
if firstHalfTotal > secondHalfTotal {
return domain.OUTCOME_STATUS_WIN, nil
if firstHalfWinner != outcome.HomeTeamName && firstHalfWinner != outcome.AwayTeamName && firstHalfWinner != "Tie" {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", firstHalfWinner)
}
case "2nd Half":
if firstHalfTotal < secondHalfTotal {
return domain.OUTCOME_STATUS_WIN, nil
if secondHalfWinner != outcome.HomeTeamName && secondHalfWinner != outcome.AwayTeamName && secondHalfWinner != "Tie" {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", firstHalfWinner)
}
case "Tie":
if firstHalfTotal == secondHalfTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", outcome.OddName)
}
return domain.OUTCOME_STATUS_LOSS, nil
}
// Highest Scoring Quarter betting is a type of bet where the bettor predicts which quarter of the match will have the highest score.
func evaluateHighestScoringQuarter(outcome domain.BetOutcome, firstScore struct{ Home, Away int }, secondScore struct{ Home, Away int }, thirdScore struct{ Home, Away int }, fourthScore struct{ Home, Away int }) (domain.OutcomeStatus, error) {
firstQuarterTotal := firstScore.Home + firstScore.Away
secondQuarterTotal := secondScore.Home + secondScore.Away
thirdQuarterTotal := thirdScore.Home + thirdScore.Away
fourthQuarterTotal := fourthScore.Home + fourthScore.Away
switch outcome.OddName {
case "1st Quarter":
if firstQuarterTotal > secondQuarterTotal && firstQuarterTotal > thirdQuarterTotal && firstQuarterTotal > fourthQuarterTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
case "2nd Quarter":
if secondQuarterTotal > firstQuarterTotal && secondQuarterTotal > thirdQuarterTotal && secondQuarterTotal > fourthQuarterTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
case "3rd Quarter":
if thirdQuarterTotal > firstQuarterTotal && thirdQuarterTotal > secondQuarterTotal && thirdQuarterTotal > fourthQuarterTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
case "4th Quarter":
if fourthQuarterTotal > firstQuarterTotal && fourthQuarterTotal > secondQuarterTotal && fourthQuarterTotal > thirdQuarterTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
case "Tie":
if firstQuarterTotal == secondQuarterTotal || secondQuarterTotal == thirdQuarterTotal || thirdQuarterTotal == fourthQuarterTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", outcome.OddName)
}
return domain.OUTCOME_STATUS_LOSS, nil
}
// Team With Highest Scoring Quarter betting is a type of bet where the bettor predicts which team will have the highest score in a specific quarter.
func evaluateTeamWithHighestScoringQuarter(outcome domain.BetOutcome, firstScore struct{ Home, Away int }, secondScore struct{ Home, Away int }, thirdScore struct{ Home, Away int }, fourthScore struct{ Home, Away int }) (domain.OutcomeStatus, error) {
homeTeamHighestQuarter := max(firstScore.Home, secondScore.Home, thirdScore.Home, fourthScore.Home)
awayTeamHighestQuarter := max(firstScore.Away, secondScore.Away, thirdScore.Away, fourthScore.Away)
switch outcome.OddName {
case "1":
if homeTeamHighestQuarter > awayTeamHighestQuarter {
return domain.OUTCOME_STATUS_WIN, nil
}
case "2":
if awayTeamHighestQuarter > homeTeamHighestQuarter {
return domain.OUTCOME_STATUS_WIN, nil
}
case "Tie":
if homeTeamHighestQuarter == awayTeamHighestQuarter {
return domain.OUTCOME_STATUS_WIN, nil
}
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", outcome.OddName)
}
return domain.OUTCOME_STATUS_LOSS, nil
}
// Handicap and Total betting is a combination of spread betting and total points betting
// where the bettor predicts the outcome of a match with a point spread and the total number of points scored is over or under a specified number.
func evaluateHandicapAndTotal(outcome domain.BetOutcome, score struct{ Home, Away int }) (domain.OutcomeStatus, error) {
nameSplit := strings.Split(outcome.OddName, " ")
// Evaluate from bottom to get the threshold and find out if its over or under
threshold, err := strconv.ParseFloat(nameSplit[len(nameSplit)-1], 10)
if err != nil {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("failed parsing threshold: %s", outcome.OddName)
}
total := float64(score.Home + score.Away)
overUnder := nameSplit[len(nameSplit)-2]
if overUnder == "Over" {
if total < threshold {
switch {
case firstHalfWinner == outcome.HomeTeamName && firstHalfScore.Home < firstHalfScore.Away:
return domain.OUTCOME_STATUS_LOSS, nil
case firstHalfWinner == outcome.AwayTeamName && firstHalfScore.Away < firstHalfScore.Home:
return domain.OUTCOME_STATUS_LOSS, nil
case firstHalfWinner == "Tie" && firstHalfScore.Home != firstHalfScore.Away:
return domain.OUTCOME_STATUS_LOSS, nil
}
} else if overUnder == "Under" {
if total > threshold {
switch {
case secondHalfWinner == outcome.HomeTeamName && firstHalfScore.Home < firstHalfScore.Away:
return domain.OUTCOME_STATUS_LOSS, nil
case secondHalfWinner == outcome.AwayTeamName && firstHalfScore.Away < firstHalfScore.Home:
return domain.OUTCOME_STATUS_LOSS, nil
case secondHalfWinner == "Tie" && firstHalfScore.Home != firstHalfScore.Away:
return domain.OUTCOME_STATUS_LOSS, nil
}
} else {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("failed parsing over and under: %s", outcome.OddName)
return domain.OUTCOME_STATUS_WIN, nil
}
handicap, err := strconv.ParseFloat(nameSplit[len(nameSplit)-4], 10)
if err != nil {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("failed parsing handicap: %s", outcome.OddName)
}
teamName := strings.TrimSpace(strings.Join(nameSplit[:len(nameSplit)-4], ""))
adjustedHomeScore := float64(score.Home)
adjustedAwayScore := float64(score.Away)
switch teamName {
case outcome.HomeTeamName:
adjustedHomeScore += handicap
if adjustedHomeScore > adjustedAwayScore {
return domain.OUTCOME_STATUS_WIN, nil
// Highest Scoring Half betting is a type of bet where the bettor predicts which half of the match will have the highest total score.
func evaluateHighestScoringHalf(outcome domain.BetOutcome, firstScore struct{ Home, Away int }, secondScore struct{ Home, Away int }) (domain.OutcomeStatus, error) {
firstHalfTotal := firstScore.Home + firstScore.Away
secondHalfTotal := secondScore.Home + secondScore.Away
switch outcome.OddName {
case "1st Half":
if firstHalfTotal > secondHalfTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
case "2nd Half":
if firstHalfTotal < secondHalfTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
case "Tie":
if firstHalfTotal == secondHalfTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", outcome.OddName)
}
return domain.OUTCOME_STATUS_LOSS, nil
case outcome.AwayTeamName:
adjustedAwayScore += handicap
if adjustedAwayScore > adjustedHomeScore {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("failed parsing team name: %s", outcome.OddName)
}
}
// Highest Scoring Quarter betting is a type of bet where the bettor predicts which quarter of the match will have the highest score.
func evaluateHighestScoringQuarter(outcome domain.BetOutcome, firstScore struct{ Home, Away int }, secondScore struct{ Home, Away int }, thirdScore struct{ Home, Away int }, fourthScore struct{ Home, Away int }) (domain.OutcomeStatus, error) {
firstQuarterTotal := firstScore.Home + firstScore.Away
secondQuarterTotal := secondScore.Home + secondScore.Away
thirdQuarterTotal := thirdScore.Home + thirdScore.Away
fourthQuarterTotal := fourthScore.Home + fourthScore.Away
// Winning Margin betting is a type of bet where the bettor predicts the margin of victory in a match.
func evaluateWinningMargin(outcome domain.BetOutcome, score struct{ Home, Away int }) (domain.OutcomeStatus, error) {
switch outcome.OddName {
case "1st Quarter":
if firstQuarterTotal > secondQuarterTotal && firstQuarterTotal > thirdQuarterTotal && firstQuarterTotal > fourthQuarterTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
case "2nd Quarter":
if secondQuarterTotal > firstQuarterTotal && secondQuarterTotal > thirdQuarterTotal && secondQuarterTotal > fourthQuarterTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
case "3rd Quarter":
if thirdQuarterTotal > firstQuarterTotal && thirdQuarterTotal > secondQuarterTotal && thirdQuarterTotal > fourthQuarterTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
case "4th Quarter":
if fourthQuarterTotal > firstQuarterTotal && fourthQuarterTotal > secondQuarterTotal && fourthQuarterTotal > thirdQuarterTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
case "Tie":
if firstQuarterTotal == secondQuarterTotal || secondQuarterTotal == thirdQuarterTotal || thirdQuarterTotal == fourthQuarterTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", outcome.OddName)
}
return domain.OUTCOME_STATUS_LOSS, nil
}
// Team With Highest Scoring Quarter betting is a type of bet where the bettor predicts which team will have the highest score in a specific quarter.
func evaluateTeamWithHighestScoringQuarter(outcome domain.BetOutcome, firstScore struct{ Home, Away int }, secondScore struct{ Home, Away int }, thirdScore struct{ Home, Away int }, fourthScore struct{ Home, Away int }) (domain.OutcomeStatus, error) {
homeTeamHighestQuarter := max(firstScore.Home, secondScore.Home, thirdScore.Home, fourthScore.Home)
awayTeamHighestQuarter := max(firstScore.Away, secondScore.Away, thirdScore.Away, fourthScore.Away)
switch outcome.OddName {
case "1":
if homeTeamHighestQuarter > awayTeamHighestQuarter {
return domain.OUTCOME_STATUS_WIN, nil
}
case "2":
if awayTeamHighestQuarter > homeTeamHighestQuarter {
return domain.OUTCOME_STATUS_WIN, nil
}
case "Tie":
if homeTeamHighestQuarter == awayTeamHighestQuarter {
return domain.OUTCOME_STATUS_WIN, nil
}
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", outcome.OddName)
}
return domain.OUTCOME_STATUS_LOSS, nil
}
// Handicap and Total betting is a combination of spread betting and total points betting
// where the bettor predicts the outcome of a match with a point spread and the total number of points scored is over or under a specified number.
func evaluateHandicapAndTotal(outcome domain.BetOutcome, score struct{ Home, Away int }) (domain.OutcomeStatus, error) {
nameSplit := strings.Split(outcome.OddName, " ")
// Evaluate from bottom to get the threshold and find out if its over or under
threshold, err := strconv.ParseFloat(nameSplit[len(nameSplit)-1], 10)
if err != nil {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("failed parsing threshold: %s", outcome.OddName)
}
total := float64(score.Home + score.Away)
overUnder := nameSplit[len(nameSplit)-2]
if overUnder == "Over" {
if total < threshold {
return domain.OUTCOME_STATUS_LOSS, nil
}
} else if overUnder == "Under" {
if total > threshold {
return domain.OUTCOME_STATUS_LOSS, nil
}
} else {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("failed parsing over and under: %s", outcome.OddName)
}
handicap, err := strconv.ParseFloat(nameSplit[len(nameSplit)-4], 10)
if err != nil {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("failed parsing handicap: %s", outcome.OddName)
}
teamName := strings.TrimSpace(strings.Join(nameSplit[:len(nameSplit)-4], ""))
adjustedHomeScore := float64(score.Home)
adjustedAwayScore := float64(score.Away)
switch teamName {
case outcome.HomeTeamName:
adjustedHomeScore += handicap
if adjustedHomeScore > adjustedAwayScore {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
case outcome.AwayTeamName:
adjustedAwayScore += handicap
if adjustedAwayScore > adjustedHomeScore {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("failed parsing team name: %s", outcome.OddName)
}
}
// Winning Margin betting is a type of bet where the bettor predicts the margin of victory in a match.
func evaluateWinningMargin(outcome domain.BetOutcome, score struct{ Home, Away int }) (domain.OutcomeStatus, error) {
marginSplit := strings.Split(outcome.OddName, "")
if len(marginSplit) < 1 {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", outcome.OddName)
}
margin, err := strconv.ParseInt(marginSplit[0], 10, 64)
if err != nil {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", outcome.OddName)
}
isGtr := false
if len(marginSplit) == 2 {
isGtr = marginSplit[1] == "+"
}
switch outcome.OddHeader {
case "1":
if score.Home == (score.Away + int(margin)) {
return domain.OUTCOME_STATUS_WIN, nil
} else if isGtr && score.Home > (score.Away+int(margin)) {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
case "2":
if (score.Home + int(margin)) == score.Away {
return domain.OUTCOME_STATUS_WIN, nil
} else if isGtr && (score.Home+int(margin)) > score.Away {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
}
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddheader: %s", outcome.OddHeader)
}
// Highest Scoring Period betting is a type of bet where the bettor predicts which period of the match will have the highest total score.
func evaluateHighestScoringPeriod(outcome domain.BetOutcome, firstScore struct{ Home, Away int }, secondScore struct{ Home, Away int }, thirdScore struct{ Home, Away int }) (domain.OutcomeStatus, error) {
firstPeriodTotal := firstScore.Home + firstScore.Away
secondPeriodTotal := secondScore.Home + secondScore.Away
thirdPeriodTotal := thirdScore.Home + thirdScore.Away
switch outcome.OddName {
case "Period 1":
if firstPeriodTotal > secondPeriodTotal && firstPeriodTotal > thirdPeriodTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
case "Period 2":
if secondPeriodTotal > firstPeriodTotal && secondPeriodTotal > thirdPeriodTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
case "Period 3":
if thirdPeriodTotal > firstPeriodTotal && thirdPeriodTotal > secondPeriodTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
case "Tie":
if firstPeriodTotal == secondPeriodTotal || secondPeriodTotal == thirdPeriodTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", outcome.OddName)
}
return domain.OUTCOME_STATUS_LOSS, nil
}
// Tied After Regulation is a type of bet where the bettor predicts whether the match will end in a tie after regulation time.
func evaluateTiedAfterRegulation(outcome domain.BetOutcome, scores []struct{ Home, Away int }) (domain.OutcomeStatus, error) {
totalScore := struct{ Home, Away int }{0, 0}
for _, score := range scores {
totalScore.Home += score.Home
totalScore.Away += score.Away
}
switch outcome.OddName {
case "Yes":
if totalScore.Home == totalScore.Away {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
case "No":
if totalScore.Home != totalScore.Away {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
}
marginSplit := strings.Split(outcome.OddName, "")
if len(marginSplit) < 1 {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", outcome.OddName)
}
margin, err := strconv.ParseInt(marginSplit[0], 10, 64)
if err != nil {
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", outcome.OddName)
// evaluateRugbyOutcome evaluates the outcome of a Rugby bet
func evaluateRugbyOutcome(outcome domain.BetOutcome, result *domain.RugbyResultResponse) (domain.OutcomeStatus, error) {
finalScore := parseSS(result.SS)
switch outcome.MarketName {
case "Money Line":
return evaluateRugbyMoneyLine(outcome, finalScore)
case "Spread":
return evaluateRugbySpread(outcome, finalScore)
case "Total Points":
return evaluateRugbyTotalPoints(outcome, finalScore)
default:
return domain.OUTCOME_STATUS_PENDING, fmt.Errorf("unsupported rugby market: %s", outcome.MarketName)
}
}
isGtr := false
if len(marginSplit) == 2 {
isGtr = marginSplit[1] == "+"
// evaluateBaseballOutcome evaluates the outcome of a Baseball bet
func evaluateBaseballOutcome(outcome domain.BetOutcome, result *domain.BaseballResultResponse) (domain.OutcomeStatus, error) {
finalScore := parseSS(result.SS)
switch outcome.MarketName {
case "Money Line":
return evaluateBaseballMoneyLine(outcome, finalScore)
case "Spread":
return evaluateBaseballSpread(outcome, finalScore)
case "Total Runs":
return evaluateBaseballTotalRuns(outcome, finalScore)
default:
return domain.OUTCOME_STATUS_PENDING, fmt.Errorf("unsupported baseball market: %s", outcome.MarketName)
}
}
switch outcome.OddHeader {
case "1":
if score.Home == (score.Away + int(margin)) {
return domain.OUTCOME_STATUS_WIN, nil
} else if isGtr && score.Home > (score.Away+int(margin)) {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
case "2":
if (score.Home + int(margin)) == score.Away {
return domain.OUTCOME_STATUS_WIN, nil
} else if isGtr && (score.Home+int(margin)) > score.Away {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
}
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddheader: %s", outcome.OddHeader)
}
// Highest Scoring Period betting is a type of bet where the bettor predicts which period of the match will have the highest total score.
func evaluateHighestScoringPeriod(outcome domain.BetOutcome, firstScore struct{ Home, Away int }, secondScore struct{ Home, Away int }, thirdScore struct{ Home, Away int }) (domain.OutcomeStatus, error) {
firstPeriodTotal := firstScore.Home + firstScore.Away
secondPeriodTotal := secondScore.Home + secondScore.Away
thirdPeriodTotal := thirdScore.Home + thirdScore.Away
switch outcome.OddName {
case "Period 1":
if firstPeriodTotal > secondPeriodTotal && firstPeriodTotal > thirdPeriodTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
case "Period 2":
if secondPeriodTotal > firstPeriodTotal && secondPeriodTotal > thirdPeriodTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
case "Period 3":
if thirdPeriodTotal > firstPeriodTotal && thirdPeriodTotal > secondPeriodTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
case "Tie":
if firstPeriodTotal == secondPeriodTotal || secondPeriodTotal == thirdPeriodTotal {
return domain.OUTCOME_STATUS_WIN, nil
}
default:
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", outcome.OddName)
}
return domain.OUTCOME_STATUS_LOSS, nil
}
// Tied After Regulation is a type of bet where the bettor predicts whether the match will end in a tie after regulation time.
func evaluateTiedAfterRegulation(outcome domain.BetOutcome, scores []struct{ Home, Away int }) (domain.OutcomeStatus, error) {
totalScore := struct{ Home, Away int }{0, 0}
for _, score := range scores {
totalScore.Home += score.Home
totalScore.Away += score.Away
}
switch outcome.OddName {
case "Yes":
if totalScore.Home == totalScore.Away {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
case "No":
if totalScore.Home != totalScore.Away {
return domain.OUTCOME_STATUS_WIN, nil
}
return domain.OUTCOME_STATUS_LOSS, nil
}
return domain.OUTCOME_STATUS_ERROR, fmt.Errorf("invalid oddname: %s", outcome.OddName)
}
// evaluateRugbyOutcome evaluates the outcome of a Rugby bet
func evaluateRugbyOutcome(outcome domain.BetOutcome, result *domain.RugbyResultResponse) (domain.OutcomeStatus, error) {
finalScore := parseSS(result.SS)
switch outcome.MarketName {
case "Money Line":
return evaluateRugbyMoneyLine(outcome, finalScore)
case "Spread":
return evaluateRugbySpread(outcome, finalScore)
case "Total Points":
return evaluateRugbyTotalPoints(outcome, finalScore)
default:
return domain.OUTCOME_STATUS_PENDING, fmt.Errorf("unsupported rugby market: %s", outcome.MarketName)
}
}
// evaluateBaseballOutcome evaluates the outcome of a Baseball bet
func evaluateBaseballOutcome(outcome domain.BetOutcome, result *domain.BaseballResultResponse) (domain.OutcomeStatus, error) {
finalScore := parseSS(result.SS)
switch outcome.MarketName {
case "Money Line":
return evaluateBaseballMoneyLine(outcome, finalScore)
case "Spread":
return evaluateBaseballSpread(outcome, finalScore)
case "Total Runs":
return evaluateBaseballTotalRuns(outcome, finalScore)
default:
return domain.OUTCOME_STATUS_PENDING, fmt.Errorf("unsupported baseball market: %s", outcome.MarketName)
}
}

2
internal/services/result/service.go
View File

@ -16,7 +16,7 @@ import (
"github.com/SamuelTariku/FortuneBet-Backend/internal/services/bet"
)
type Service struct {
type Service struct {
repo *repository.Store
config *config.Config
logger *slog.Logger

49
internal/services/result/service_test.go Normal file
View File

@ -0,0 +1,49 @@
package result
import (
"fmt"
"testing"
"time"
"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
)
func TestEvaluateFootballOutcome(t *testing.T) {
service := &Service{} // or your real logger
// Mock outcome
outcome := domain.BetOutcome{
ID: 1,
BetID: 1,
EventID: 1001,
OddID: 2001,
SportID: 1, // Assuming 1 = Football
HomeTeamName: "Manchester",
AwayTeamName: "Liverpool",
MarketID: int64(domain.FOOTBALL_FULL_TIME_RESULT),
MarketName: "Full Time Result",
Odd: 1.75,
OddName: "2", // Home win
OddHeader: "1",
OddHandicap: "",
Status: domain.OUTCOME_STATUS_PENDING, // Initial status
Expires: time.Now().Add(24 * time.Hour),
}
// Parsed result (simulate Bet365 JSON)
finalScore := struct{ Home, Away int }{Home: 2, Away: 1}
firstHalfScore := struct{ Home, Away int }{Home: 1, Away: 1}
secondHalfScore := struct{ Home, Away int }{Home: 1, Away: 0}
corners := struct{ Home, Away int }{Home: 5, Away: 3}
halfTimeCorners := struct{ Home, Away int }{Home: 2, Away: 2}
events := []map[string]string{
{"type": "goal", "team": "home", "minute": "23"},
{"type": "goal", "team": "away", "minute": "34"},
}
// Act
status, _ := service.evaluateFootballOutcome(outcome, finalScore, firstHalfScore, secondHalfScore, corners, halfTimeCorners, events)
fmt.Printf("\n\nBet Outcome: %v\n\n", &status)
}

2
internal/web_server/handlers/veli_games.go
View File

@ -42,7 +42,7 @@ func (h *Handler) LaunchVeliGame(c *fiber.Ctx) error {
// HandleVeliCallback godoc
// @Summary Veli Games webhook handler
// @Description Processes game round settlements from Veli
// @Tags Virtual Games
// @Tags Veli Games
// @Accept json
// @Produce json
// @Param payload body domain.VeliCallback true "Callback payload"

6
internal/web_server/routes.go
View File

@ -194,11 +194,11 @@ func (a *App) initAppRoutes() {
group.Post("/webhooks/alea-play", a.authMiddleware, h.HandleAleaCallback)
//Veli Virtual Game Routes
group.Get("/veli-games/launch", a.authMiddleware, h.LaunchVeliGame)
group.Post("/webhooks/veli-games", a.authMiddleware, h.HandleVeliCallback)
group.Get("/veli-games/launch", h.LaunchVeliGame)
group.Post("/webhooks/veli-games", h.HandleVeliCallback)
// Recommendation Routes
group.Get("/virtual-games/recommendations/:userID", a.authMiddleware, h.GetRecommendations)
group.Get("/virtual-games/recommendations/:userID", h.GetRecommendations)
// Transactions /transactions
a.fiber.Post("/transaction", a.authMiddleware, h.CreateTransaction)