832 lines
23 KiB
Go
832 lines
23 KiB
Go
package odds
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"log/slog"
|
|
"net/http"
|
|
"strconv"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/config"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/repository"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/services/event"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
type ServiceImpl struct {
|
|
store *repository.Store
|
|
config *config.Config
|
|
eventSvc event.Service
|
|
logger *slog.Logger
|
|
mongoLogger *zap.Logger
|
|
client *http.Client
|
|
}
|
|
|
|
func New(store *repository.Store, cfg *config.Config, eventSvc event.Service, logger *slog.Logger, mongoLogger *zap.Logger) *ServiceImpl {
|
|
return &ServiceImpl{
|
|
store: store,
|
|
config: cfg,
|
|
eventSvc: eventSvc,
|
|
logger: logger,
|
|
mongoLogger: mongoLogger,
|
|
client: &http.Client{Timeout: 10 * time.Second},
|
|
}
|
|
}
|
|
|
|
// TODO Add the optimization to get 10 events at the same time
|
|
func (s *ServiceImpl) FetchNonLiveOdds(ctx context.Context) error {
|
|
var wg sync.WaitGroup
|
|
errChan := make(chan error, 2)
|
|
// wg.Add(2)
|
|
wg.Add(1)
|
|
|
|
go func() {
|
|
defer wg.Done()
|
|
if err := s.fetchBet365Odds(ctx); err != nil {
|
|
errChan <- fmt.Errorf("bet365 odds fetching error: %w", err)
|
|
}
|
|
}()
|
|
|
|
// go func() {
|
|
// defer wg.Done()
|
|
// if err := s.fetchBwinOdds(ctx); err != nil {
|
|
// errChan <- fmt.Errorf("bwin odds fetching error: %w", err)
|
|
// }
|
|
// }()
|
|
|
|
go func() {
|
|
wg.Wait()
|
|
close(errChan)
|
|
}()
|
|
|
|
var errs []error
|
|
for err := range errChan {
|
|
errs = append(errs, err)
|
|
}
|
|
|
|
if len(errs) > 0 {
|
|
return errors.Join(errs...)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *ServiceImpl) fetchBet365Odds(ctx context.Context) error {
|
|
eventIDs, err := s.eventSvc.GetAllUpcomingEvents(ctx)
|
|
if err != nil {
|
|
s.mongoLogger.Error(
|
|
"Failed to fetch upcoming event IDs",
|
|
zap.Error(err),
|
|
)
|
|
return err
|
|
}
|
|
|
|
var errs []error
|
|
|
|
for index, event := range eventIDs {
|
|
log.Printf("📡 Fetching prematch odds for event ID: %v (%d/%d) ", event.ID, index, len(eventIDs))
|
|
|
|
oddsData, err := s.FetchNonLiveOddsByEventID(ctx, event.ID)
|
|
if err != nil || oddsData.Success != 1 {
|
|
s.mongoLogger.Error(
|
|
"Failed to fetch prematch odds",
|
|
zap.String("eventID", event.ID),
|
|
zap.Error(err),
|
|
)
|
|
errs = append(errs, fmt.Errorf("failed to fetch prematch odds for event %v: %w", event.ID, err))
|
|
continue
|
|
}
|
|
|
|
parsedOddSections, err := s.ParseOddSections(ctx, oddsData.Results[0], event.SportID)
|
|
if err != nil {
|
|
s.mongoLogger.Error(
|
|
"Failed to parse odd section",
|
|
zap.String("eventID", event.ID),
|
|
zap.Int32("sportID", event.SportID),
|
|
zap.Error(err),
|
|
)
|
|
errs = append(errs, fmt.Errorf("failed to parse odd section for event %v: %w", event.ID, err))
|
|
continue
|
|
}
|
|
|
|
if parsedOddSections.EventFI == "" {
|
|
s.mongoLogger.Error(
|
|
"Skipping result with no valid Event FI field",
|
|
zap.String("FI", parsedOddSections.EventFI),
|
|
zap.String("eventID", event.ID),
|
|
zap.Int32("sportID", event.SportID),
|
|
zap.Error(err),
|
|
)
|
|
errs = append(errs, errors.New("event FI is empty"))
|
|
continue
|
|
}
|
|
|
|
for oddCategory, section := range parsedOddSections.Sections {
|
|
if err := s.storeSection(ctx, event.ID, parsedOddSections.EventFI, oddCategory, section); err != nil {
|
|
s.mongoLogger.Error(
|
|
"Error storing odd section",
|
|
zap.String("eventID", event.ID),
|
|
zap.String("odd", oddCategory),
|
|
zap.Int32("sportID", event.SportID),
|
|
zap.Error(err),
|
|
)
|
|
errs = append(errs, err)
|
|
}
|
|
}
|
|
for _, section := range parsedOddSections.OtherRes {
|
|
if err := s.storeSection(ctx, event.ID, parsedOddSections.EventFI, "others", section); err != nil {
|
|
s.mongoLogger.Error(
|
|
"Error storing odd other section",
|
|
zap.String("eventID", event.ID),
|
|
zap.Int32("sportID", event.SportID),
|
|
zap.Error(err),
|
|
)
|
|
errs = append(errs, err)
|
|
continue
|
|
}
|
|
}
|
|
|
|
// result := oddsData.Results[0]
|
|
|
|
}
|
|
|
|
for err := range errs {
|
|
log.Printf("❌ Error: %v", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// func (s *ServiceImpl) fetchBwinOdds(ctx context.Context) error {
|
|
// // getting odds for a specific event is not possible for bwin, most specific we can get is fetch odds on a single sport
|
|
// // so instead of having event and odds fetched separetly event will also be fetched along with the odds
|
|
// sportIds := []int{4, 12, 7}
|
|
// for _, sportId := range sportIds {
|
|
// url := fmt.Sprintf("https://api.b365api.com/v1/bwin/prematch?sport_id=%d&token=%s", sportId, s.config.Bet365Token)
|
|
// req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
|
|
// if err != nil {
|
|
// s.mongoLogger.Error(
|
|
// "Failed to create request for sportId",
|
|
// zap.Int("sportID", sportId),
|
|
// zap.Error(err),
|
|
// )
|
|
// continue
|
|
// }
|
|
|
|
// resp, err := s.client.Do(req)
|
|
// if err != nil {
|
|
// s.mongoLogger.Error(
|
|
// "Failed to fetch request for sportId",
|
|
// zap.Int("sportID", sportId),
|
|
// zap.Error(err),
|
|
// )
|
|
// continue
|
|
// }
|
|
// defer resp.Body.Close()
|
|
|
|
// body, err := io.ReadAll(resp.Body)
|
|
// if err != nil {
|
|
// s.mongoLogger.Error(
|
|
// "Failed to read response body for sportId",
|
|
// zap.Int("sportID", sportId),
|
|
// zap.Error(err),
|
|
// )
|
|
// continue
|
|
// }
|
|
|
|
// var data struct {
|
|
// Success int `json:"success"`
|
|
// Results []map[string]interface{} `json:"results"`
|
|
// }
|
|
|
|
// if err := json.Unmarshal(body, &data); err != nil || data.Success != 1 {
|
|
// fmt.Printf("Decode failed for sport_id=%d\nRaw: %s\n", sportId, string(body))
|
|
// s.mongoLogger.Error(
|
|
// "Failed to decode BWin response body",
|
|
// zap.Int("sportID", sportId),
|
|
// zap.Error(err),
|
|
// )
|
|
// continue
|
|
// }
|
|
|
|
// for _, res := range data.Results {
|
|
// if getInt(res["Id"]) == -1 {
|
|
// continue
|
|
// }
|
|
|
|
// event := domain.CreateEvent{
|
|
// ID: strconv.Itoa(getInt(res["Id"])),
|
|
// SportID: int32(getInt(res["SportId"])),
|
|
// LeagueID: int64(getInt(res["LeagueId"])),
|
|
// LeagueName: getString(res["Leaguename"]),
|
|
// HomeTeam: getString(res["HomeTeam"]),
|
|
// HomeTeamID: int64(getInt(res["HomeTeamId"])),
|
|
// AwayTeam: getString(res["AwayTeam"]),
|
|
// AwayTeamID: int64(getInt(res["AwayTeamId"])),
|
|
// StartTime: time.Now().UTC(),
|
|
// IsLive: true,
|
|
// Status: domain.STATUS_IN_PLAY,
|
|
// Source: domain.EVENT_SOURCE_BWIN,
|
|
// MatchName: "",
|
|
// HomeTeamImage: "",
|
|
// AwayTeamImage: "",
|
|
// }
|
|
|
|
// if err := s.store.SaveEvent(ctx, event); err != nil {
|
|
// fmt.Printf("Could not store live event [id=%s]: %v\n", event.ID, err)
|
|
// s.mongoLogger.Error(
|
|
// "Could not store live event",
|
|
// zap.Int("sportID", sportId),
|
|
// zap.String("eventID", event.ID),
|
|
// zap.Error(err),
|
|
// )
|
|
// continue
|
|
// }
|
|
|
|
// for _, market := range []string{"Markets, optionMarkets"} {
|
|
// for _, m := range getMapArray(res[market]) {
|
|
// name := getMap(m["name"])
|
|
// marketName := getString(name["value"])
|
|
|
|
// market := domain.CreateOddMarket{
|
|
// EventID: event.ID,
|
|
// MarketID: getString(m["id"]),
|
|
// MarketCategory: getString(m["category"]),
|
|
// MarketName: marketName,
|
|
|
|
// }
|
|
|
|
// results := getMapArray(m["results"])
|
|
// market.Odds = results
|
|
|
|
// s.store.SaveOddMarket(ctx, market)
|
|
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// }
|
|
// return nil
|
|
// }
|
|
|
|
func (s *ServiceImpl) FetchNonLiveOddsByEventID(ctx context.Context, eventIDStr string) (domain.BaseNonLiveOddResponse, error) {
|
|
|
|
eventID, err := strconv.ParseInt(eventIDStr, 10, 64)
|
|
if err != nil {
|
|
s.logger.Error("Failed to parse event id")
|
|
s.mongoLogger.Error(
|
|
"Failed to parse event id",
|
|
zap.String("eventID", eventIDStr),
|
|
zap.Error(err),
|
|
)
|
|
return domain.BaseNonLiveOddResponse{}, err
|
|
}
|
|
|
|
url := fmt.Sprintf("https://api.b365api.com/v3/bet365/prematch?token=%s&FI=%d", s.config.Bet365Token, eventID)
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
|
|
if err != nil {
|
|
s.mongoLogger.Error(
|
|
"Failed to create request for event",
|
|
zap.String("eventID", eventIDStr),
|
|
zap.Error(err),
|
|
)
|
|
|
|
}
|
|
|
|
resp, err := s.client.Do(req)
|
|
if err != nil {
|
|
s.mongoLogger.Error(
|
|
"Failed to fetch prematch odds for event",
|
|
zap.String("eventID", eventIDStr),
|
|
zap.Error(err),
|
|
)
|
|
return domain.BaseNonLiveOddResponse{}, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
s.mongoLogger.Error(
|
|
"Failed to read response body for event",
|
|
zap.String("eventID", eventIDStr),
|
|
zap.Error(err),
|
|
)
|
|
return domain.BaseNonLiveOddResponse{}, err
|
|
}
|
|
var oddsData domain.BaseNonLiveOddResponse
|
|
|
|
if err := json.Unmarshal(body, &oddsData); err != nil || oddsData.Success != 1 || len(oddsData.Results) == 0 {
|
|
s.mongoLogger.Error(
|
|
"Invalid prematch data for event",
|
|
zap.String("eventID", eventIDStr),
|
|
zap.Error(err),
|
|
)
|
|
return domain.BaseNonLiveOddResponse{}, err
|
|
}
|
|
|
|
return oddsData, nil
|
|
}
|
|
|
|
func (s *ServiceImpl) ParseOddSections(ctx context.Context, res json.RawMessage, sportID int32) (domain.ParseOddSectionsRes, error) {
|
|
var sections map[string]domain.OddsSection
|
|
var OtherRes []domain.OddsSection
|
|
var eventFI string
|
|
switch sportID {
|
|
case domain.FOOTBALL:
|
|
var footballRes domain.FootballOddsResponse
|
|
if err := json.Unmarshal(res, &footballRes); err != nil {
|
|
s.mongoLogger.Error(
|
|
"Failed to unmarshal football result",
|
|
zap.Error(err),
|
|
)
|
|
return domain.ParseOddSectionsRes{}, err
|
|
}
|
|
eventFI = footballRes.FI
|
|
sections = map[string]domain.OddsSection{
|
|
"main": footballRes.Main,
|
|
"asian_lines": footballRes.AsianLines,
|
|
"goals": footballRes.Goals,
|
|
"half": footballRes.Half,
|
|
}
|
|
case domain.BASKETBALL:
|
|
var basketballRes domain.BasketballOddsResponse
|
|
if err := json.Unmarshal(res, &basketballRes); err != nil {
|
|
s.mongoLogger.Error(
|
|
"Failed to unmarshal basketball result",
|
|
zap.Error(err),
|
|
)
|
|
return domain.ParseOddSectionsRes{}, err
|
|
}
|
|
eventFI = basketballRes.FI
|
|
OtherRes = basketballRes.Others
|
|
sections = map[string]domain.OddsSection{
|
|
"main": basketballRes.Main,
|
|
"half_props": basketballRes.HalfProps,
|
|
"quarter_props": basketballRes.QuarterProps,
|
|
"team_props": basketballRes.TeamProps,
|
|
}
|
|
|
|
case domain.ICE_HOCKEY:
|
|
var iceHockeyRes domain.IceHockeyOddsResponse
|
|
if err := json.Unmarshal(res, &iceHockeyRes); err != nil {
|
|
|
|
s.mongoLogger.Error(
|
|
"Failed to unmarshal ice hockey result",
|
|
zap.Error(err),
|
|
)
|
|
return domain.ParseOddSectionsRes{}, err
|
|
}
|
|
eventFI = iceHockeyRes.FI
|
|
OtherRes = iceHockeyRes.Others
|
|
sections = map[string]domain.OddsSection{
|
|
"main": iceHockeyRes.Main,
|
|
"main_2": iceHockeyRes.Main2,
|
|
"1st_period": iceHockeyRes.FirstPeriod,
|
|
}
|
|
case domain.CRICKET:
|
|
var cricketRes domain.CricketOddsResponse
|
|
if err := json.Unmarshal(res, &cricketRes); err != nil {
|
|
s.mongoLogger.Error(
|
|
"Failed to unmarshal cricket result",
|
|
zap.Error(err),
|
|
)
|
|
return domain.ParseOddSectionsRes{}, err
|
|
}
|
|
eventFI = cricketRes.FI
|
|
OtherRes = cricketRes.Others
|
|
sections = map[string]domain.OddsSection{
|
|
"1st_over": cricketRes.Main,
|
|
"innings_1": cricketRes.First_Innings,
|
|
"main": cricketRes.Main,
|
|
"match": cricketRes.Match,
|
|
"player": cricketRes.Player,
|
|
"team": cricketRes.Team,
|
|
}
|
|
case domain.VOLLEYBALL:
|
|
var volleyballRes domain.VolleyballOddsResponse
|
|
if err := json.Unmarshal(res, &volleyballRes); err != nil {
|
|
s.mongoLogger.Error(
|
|
"Failed to unmarshal volleyball result",
|
|
zap.Error(err),
|
|
)
|
|
return domain.ParseOddSectionsRes{}, err
|
|
}
|
|
eventFI = volleyballRes.FI
|
|
OtherRes = volleyballRes.Others
|
|
sections = map[string]domain.OddsSection{
|
|
"main": volleyballRes.Main,
|
|
}
|
|
case domain.DARTS:
|
|
var dartsRes domain.DartsOddsResponse
|
|
if err := json.Unmarshal(res, &dartsRes); err != nil {
|
|
s.mongoLogger.Error(
|
|
"Failed to unmarshal darts result",
|
|
zap.Error(err),
|
|
)
|
|
return domain.ParseOddSectionsRes{}, err
|
|
}
|
|
eventFI = dartsRes.FI
|
|
OtherRes = dartsRes.Others
|
|
sections = map[string]domain.OddsSection{
|
|
"180s": dartsRes.OneEightys,
|
|
"extra": dartsRes.Extra,
|
|
"leg": dartsRes.Leg,
|
|
"main": dartsRes.Main,
|
|
}
|
|
case domain.FUTSAL:
|
|
var futsalRes domain.FutsalOddsResponse
|
|
if err := json.Unmarshal(res, &futsalRes); err != nil {
|
|
s.mongoLogger.Error(
|
|
"Failed to unmarshal futsal result",
|
|
zap.Error(err),
|
|
)
|
|
return domain.ParseOddSectionsRes{}, err
|
|
}
|
|
eventFI = futsalRes.FI
|
|
OtherRes = futsalRes.Others
|
|
sections = map[string]domain.OddsSection{
|
|
"main": futsalRes.Main,
|
|
"score": futsalRes.Score,
|
|
}
|
|
case domain.AMERICAN_FOOTBALL:
|
|
var americanFootballRes domain.AmericanFootballOddsResponse
|
|
if err := json.Unmarshal(res, &americanFootballRes); err != nil {
|
|
s.mongoLogger.Error(
|
|
"Failed to unmarshal american football result",
|
|
zap.Error(err),
|
|
)
|
|
return domain.ParseOddSectionsRes{}, err
|
|
}
|
|
eventFI = americanFootballRes.FI
|
|
OtherRes = americanFootballRes.Others
|
|
sections = map[string]domain.OddsSection{
|
|
"half_props": americanFootballRes.HalfProps,
|
|
"main": americanFootballRes.Main,
|
|
"quarter_props": americanFootballRes.QuarterProps,
|
|
}
|
|
case domain.RUGBY_LEAGUE:
|
|
var rugbyLeagueRes domain.RugbyLeagueOddsResponse
|
|
if err := json.Unmarshal(res, &rugbyLeagueRes); err != nil {
|
|
s.mongoLogger.Error(
|
|
"Failed to unmarshal rugby league result",
|
|
zap.Error(err),
|
|
)
|
|
return domain.ParseOddSectionsRes{}, err
|
|
}
|
|
eventFI = rugbyLeagueRes.FI
|
|
OtherRes = rugbyLeagueRes.Others
|
|
sections = map[string]domain.OddsSection{
|
|
"10minute": rugbyLeagueRes.TenMinute,
|
|
"main": rugbyLeagueRes.Main,
|
|
"main_2": rugbyLeagueRes.Main2,
|
|
"player": rugbyLeagueRes.Player,
|
|
"Score": rugbyLeagueRes.Score,
|
|
"Team": rugbyLeagueRes.Team,
|
|
}
|
|
case domain.RUGBY_UNION:
|
|
var rugbyUnionRes domain.RugbyUnionOddsResponse
|
|
if err := json.Unmarshal(res, &rugbyUnionRes); err != nil {
|
|
s.mongoLogger.Error(
|
|
"Failed to unmarshal rugby union result",
|
|
zap.Error(err),
|
|
)
|
|
return domain.ParseOddSectionsRes{}, err
|
|
}
|
|
eventFI = rugbyUnionRes.FI
|
|
OtherRes = rugbyUnionRes.Others
|
|
sections = map[string]domain.OddsSection{
|
|
"main": rugbyUnionRes.Main,
|
|
"main_2": rugbyUnionRes.Main2,
|
|
"player": rugbyUnionRes.Player,
|
|
"Score": rugbyUnionRes.Score,
|
|
"Team": rugbyUnionRes.Team,
|
|
}
|
|
case domain.BASEBALL:
|
|
var baseballRes domain.BaseballOddsResponse
|
|
if err := json.Unmarshal(res, &baseballRes); err != nil {
|
|
s.mongoLogger.Error(
|
|
"Failed to unmarshal baseball result",
|
|
zap.Error(err),
|
|
)
|
|
return domain.ParseOddSectionsRes{}, err
|
|
}
|
|
eventFI = baseballRes.FI
|
|
sections = map[string]domain.OddsSection{
|
|
"main": baseballRes.Main,
|
|
"mani_props": baseballRes.MainProps,
|
|
}
|
|
}
|
|
|
|
return domain.ParseOddSectionsRes{
|
|
Sections: sections,
|
|
OtherRes: OtherRes,
|
|
EventFI: eventFI,
|
|
}, nil
|
|
}
|
|
|
|
func (s *ServiceImpl) storeSection(ctx context.Context, eventID, fi, sectionName string, section domain.OddsSection) error {
|
|
if len(section.Sp) == 0 {
|
|
return nil
|
|
}
|
|
|
|
updatedAtUnix, _ := strconv.ParseInt(section.UpdatedAt, 10, 64)
|
|
updatedAt := time.Unix(updatedAtUnix, 0)
|
|
|
|
var errs []error
|
|
for marketType, market := range section.Sp {
|
|
if len(market.Odds) == 0 {
|
|
continue
|
|
}
|
|
|
|
// Check if the market id is a string
|
|
marketIDint := market.ID.Value
|
|
// if err != nil {
|
|
// s.mongoLogger.Error(
|
|
// "Invalid market id",
|
|
// zap.Int64("market_id", marketIDint),
|
|
// zap.String("market_name", market.Name),
|
|
// zap.String("eventID", eventID),
|
|
// zap.Error(err),
|
|
// )
|
|
// continue
|
|
// }
|
|
|
|
marketIDstr := strconv.FormatInt(marketIDint, 10)
|
|
|
|
isSupported, ok := domain.SupportedMarkets[marketIDint]
|
|
|
|
if !ok || !isSupported {
|
|
// s.logger.Info("Unsupported market_id", "marketID", marketIDint, "marketName", market.Name)
|
|
continue
|
|
}
|
|
|
|
marketOdds, err := convertRawMessage(market.Odds)
|
|
if err != nil {
|
|
s.mongoLogger.Error(
|
|
"failed to convert market.Odds to json.RawMessage to []map[string]interface{}",
|
|
zap.String("market_id", marketIDstr),
|
|
zap.String("market_name", market.Name),
|
|
zap.String("eventID", eventID),
|
|
zap.Error(err),
|
|
)
|
|
errs = append(errs, err)
|
|
continue
|
|
}
|
|
|
|
marketRecord := domain.CreateOddMarket{
|
|
EventID: eventID,
|
|
MarketCategory: sectionName,
|
|
MarketType: marketType,
|
|
MarketName: market.Name,
|
|
MarketID: marketIDstr,
|
|
UpdatedAt: updatedAt,
|
|
Odds: marketOdds,
|
|
// bwin won't reach this code so bet365 is hardcoded for now
|
|
}
|
|
|
|
if err := s.CheckAndInsertOddHistory(ctx, marketRecord); err != nil {
|
|
s.mongoLogger.Error(
|
|
"failed to check and insert odd history",
|
|
zap.String("market_id", marketIDstr),
|
|
zap.String("market_name", market.Name),
|
|
zap.String("eventID", eventID),
|
|
zap.Error(err),
|
|
)
|
|
continue
|
|
}
|
|
|
|
err = s.store.SaveOddMarket(ctx, marketRecord)
|
|
if err != nil {
|
|
s.mongoLogger.Error(
|
|
"failed to save market",
|
|
zap.String("market_id", marketIDstr),
|
|
zap.String("market_name", market.Name),
|
|
zap.String("eventID", eventID),
|
|
zap.Error(err),
|
|
)
|
|
errs = append(errs, fmt.Errorf("market %v: %w", market.ID, err))
|
|
continue
|
|
}
|
|
}
|
|
|
|
if len(errs) > 0 {
|
|
return errors.Join(errs...)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *ServiceImpl) CheckAndInsertOddHistory(ctx context.Context, market domain.CreateOddMarket) error {
|
|
isEventMonitored, err := s.eventSvc.IsEventMonitored(ctx, market.EventID)
|
|
|
|
marketLogger := s.mongoLogger.With(
|
|
zap.String("market_id", market.MarketID),
|
|
zap.String("market_name", market.MarketName),
|
|
zap.String("eventID", market.EventID),
|
|
)
|
|
if err != nil {
|
|
marketLogger.Error("failed to get is_monitored", zap.Error(err))
|
|
}
|
|
|
|
if !isEventMonitored {
|
|
return nil
|
|
}
|
|
|
|
oldOdds, err := s.store.GetOddsByMarketID(ctx, market.MarketID, market.EventID)
|
|
|
|
if err != nil {
|
|
marketLogger.Error("failed to get raw odds by market id", zap.Error(err))
|
|
return err
|
|
}
|
|
|
|
if len(oldOdds.RawOdds) != len(market.Odds) {
|
|
marketLogger.Error("new odds data does not match old odds data", zap.Error(err))
|
|
return fmt.Errorf("new odds data does not match old odds data")
|
|
}
|
|
|
|
oldRawOdds, err := convertRawMessage(oldOdds.RawOdds)
|
|
|
|
if err != nil {
|
|
marketLogger.Error("failed to convert raw odds to map", zap.Error(err))
|
|
return err
|
|
}
|
|
|
|
for _, oddData := range market.Odds {
|
|
newRawOddID := getInt(oddData["id"])
|
|
newOddsVal := getFloat(oddData["odds"])
|
|
isFound := false
|
|
for _, oldOddData := range oldRawOdds {
|
|
oldRawOddID := getInt(oldOddData["id"])
|
|
oldOddsVal := getFloat(oldOddData["odds"])
|
|
if newRawOddID == oldRawOddID {
|
|
if newOddsVal != oldOddsVal {
|
|
_, err := s.store.InsertOddHistory(ctx, domain.CreateOddHistory{
|
|
OddID: oldOdds.ID,
|
|
MarketID: market.MarketID,
|
|
RawOddID: int64(newRawOddID),
|
|
EventID: market.EventID,
|
|
OddValue: newOddsVal,
|
|
})
|
|
|
|
if err != nil {
|
|
s.mongoLogger.Error(
|
|
"failed to insert odd history",
|
|
zap.String("market_id", market.MarketID),
|
|
zap.String("market_name", market.MarketName),
|
|
zap.String("eventID", market.EventID),
|
|
zap.Int64("odd_id", oldOdds.ID),
|
|
zap.Int("raw_odd_id", newRawOddID),
|
|
zap.Error(err),
|
|
)
|
|
}
|
|
}
|
|
isFound = true
|
|
}
|
|
}
|
|
if !isFound {
|
|
fmt.Printf("raw odd id %d not found", newRawOddID)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *ServiceImpl) GetAllOdds(ctx context.Context, filter domain.OddMarketFilter) ([]domain.OddMarket, error) {
|
|
return s.store.GetAllOdds(ctx, filter)
|
|
}
|
|
|
|
func (s *ServiceImpl) GetAllOddsWithSettings(ctx context.Context, companyID int64, filter domain.OddMarketFilter) ([]domain.OddMarketWithSettings, error) {
|
|
return s.store.GetAllOddsWithSettings(ctx, companyID, filter)
|
|
}
|
|
|
|
func (s *ServiceImpl) GetOddByID(ctx context.Context, id int64) (domain.OddMarket, error) {
|
|
return s.store.GetOddByID(ctx, id)
|
|
}
|
|
|
|
func (s *ServiceImpl) SaveOddsSetting(ctx context.Context, odd domain.CreateOddMarketSettings) error {
|
|
return s.store.SaveOddsSetting(ctx, odd)
|
|
}
|
|
|
|
func (s *ServiceImpl) SaveOddsSettingReq(ctx context.Context, companyID int64, req domain.CreateOddMarketSettingsReq) error {
|
|
|
|
odd, err := s.GetOddsWithSettingsByID(ctx, req.OddMarketID, companyID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
newOdds, err := convertRawMessage(odd.RawOdds)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if len(req.CustomOdd) != 0 {
|
|
for _, customOdd := range req.CustomOdd {
|
|
for _, newOdd := range newOdds {
|
|
oldRawOddID := getInt(newOdd["id"])
|
|
|
|
if oldRawOddID == int(customOdd.OddID) {
|
|
newOdd["odds"] = customOdd.OddValue
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return s.SaveOddsSetting(ctx, domain.CreateOddMarketSettings{
|
|
CompanyID: companyID,
|
|
OddMarketID: req.OddMarketID,
|
|
IsActive: domain.ConvertBoolPtr(req.IsActive),
|
|
CustomRawOdds: newOdds,
|
|
})
|
|
}
|
|
|
|
func (s *ServiceImpl) GetOddsByMarketID(ctx context.Context, marketID string, eventID string) (domain.OddMarket, error) {
|
|
rows, err := s.store.GetOddsByMarketID(ctx, marketID, eventID)
|
|
if err != nil {
|
|
return domain.OddMarket{}, err
|
|
}
|
|
|
|
return rows, nil
|
|
}
|
|
func (s *ServiceImpl) GetOddsWithSettingsByMarketID(ctx context.Context, marketID string, eventID string, companyID int64) (domain.OddMarketWithSettings, error) {
|
|
rows, err := s.store.GetOddsWithSettingsByMarketID(ctx, marketID, eventID, companyID)
|
|
if err != nil {
|
|
return domain.OddMarketWithSettings{}, err
|
|
}
|
|
|
|
return rows, nil
|
|
}
|
|
|
|
func (s *ServiceImpl) GetOddsWithSettingsByID(ctx context.Context, ID int64, companyID int64) (domain.OddMarketWithSettings, error) {
|
|
return s.store.GetOddsWithSettingsByID(ctx, ID, companyID)
|
|
}
|
|
|
|
func (s *ServiceImpl) GetOddsByEventID(ctx context.Context, upcomingID string, filter domain.OddMarketWithEventFilter) ([]domain.OddMarket, error) {
|
|
return s.store.GetOddsByEventID(ctx, upcomingID, filter)
|
|
}
|
|
|
|
func (s *ServiceImpl) GetOddsWithSettingsByEventID(ctx context.Context, upcomingID string, companyID int64, filter domain.OddMarketFilter) ([]domain.OddMarketWithSettings, error) {
|
|
return s.store.GetOddsWithSettingsByEventID(ctx, upcomingID, companyID, filter)
|
|
}
|
|
|
|
func (s *ServiceImpl) DeleteOddsForEvent(ctx context.Context, eventID string) error {
|
|
return s.store.DeleteOddsForEvent(ctx, eventID)
|
|
}
|
|
|
|
// func getString(v interface{}) string {
|
|
// if str, ok := v.(string); ok {
|
|
// return str
|
|
// }
|
|
// return ""
|
|
// }
|
|
|
|
func getInt(v interface{}) int {
|
|
if n, ok := v.(float64); ok {
|
|
return int(n)
|
|
}
|
|
return -1
|
|
}
|
|
func getFloat(v interface{}) float64 {
|
|
if n, ok := v.(float64); ok {
|
|
return n
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func getMap(v interface{}) map[string]interface{} {
|
|
if m, ok := v.(map[string]interface{}); ok {
|
|
return m
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// func getMapArray(v interface{}) []map[string]interface{} {
|
|
// result := []map[string]interface{}{}
|
|
// if arr, ok := v.([]interface{}); ok {
|
|
// for _, item := range arr {
|
|
// if m, ok := item.(map[string]interface{}); ok {
|
|
// result = append(result, m)
|
|
// }
|
|
// }
|
|
// }
|
|
// return result
|
|
// }
|
|
|
|
func convertRawMessage(rawMessages []json.RawMessage) ([]map[string]interface{}, error) {
|
|
var result []map[string]interface{}
|
|
for _, raw := range rawMessages {
|
|
var m map[string]interface{}
|
|
if err := json.Unmarshal(raw, &m); err != nil {
|
|
return nil, err
|
|
}
|
|
result = append(result, m)
|
|
}
|
|
|
|
return result, nil
|
|
}
|