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

Merge branch 'auth' into integrate

Browse Source
This commit is contained in:
Samuel Tariku 2025-04-14 19:49:45 +03:00
commit ff393858d9
12 changed files with 653 additions and 567 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

118
db/query/odds.sql
View File

@ -1,38 +1,52 @@
-- name: InsertNonLiveOdd :exec -- name: InsertNonLiveOdd :exec
INSERT INTO odds ( INSERT INTO odds (
event_id, event_id,
fi, fi,
market_type, market_type,
market_name, market_name,
market_category, market_category,
market_id, market_id,
name, name,
handicap, handicap,
odds_value, odds_value,
section, section,
category, category,
raw_odds, raw_odds,
is_active, is_active,
source, source,
fetched_at fetched_at
) VALUES ( )
$1, $2, $3, $4, $5, $6, $7, VALUES (
$8, $9, $10, $11, $12, $13, $14, $15 $1,
) $2,
ON CONFLICT (market_id, name, handicap) DO UPDATE SET $3,
odds_value = EXCLUDED.odds_value, $4,
raw_odds = EXCLUDED.raw_odds, $5,
market_type = EXCLUDED.market_type, $6,
market_name = EXCLUDED.market_name, $7,
$8,
$9,
$10,
$11,
$12,
$13,
$14,
$15
) ON CONFLICT (event_id, market_id) DO
UPDATE
SET odds_value = EXCLUDED.odds_value,
raw_odds = EXCLUDED.raw_odds,
market_type = EXCLUDED.market_type,
market_name = EXCLUDED.market_name,
market_category = EXCLUDED.market_category, market_category = EXCLUDED.market_category,
fetched_at = EXCLUDED.fetched_at, name = EXCLUDED.name,
is_active = EXCLUDED.is_active, handicap = EXCLUDED.handicap,
source = EXCLUDED.source, fetched_at = EXCLUDED.fetched_at,
fi = EXCLUDED.fi; is_active = EXCLUDED.is_active,
source = EXCLUDED.source,
fi = EXCLUDED.fi;
-- name: GetPrematchOdds :many -- name: GetPrematchOdds :many
SELECT SELECT event_id,
event_id,
fi, fi,
market_type, market_type,
market_name, market_name,
@ -48,11 +62,10 @@ SELECT
source, source,
is_active is_active
FROM odds FROM odds
WHERE is_active = true AND source = 'b365api'; WHERE is_active = true
AND source = 'b365api';
-- name: GetALLPrematchOdds :many -- name: GetALLPrematchOdds :many
SELECT SELECT event_id,
event_id,
fi, fi,
market_type, market_type,
market_name, market_name,
@ -68,23 +81,20 @@ SELECT
source, source,
is_active is_active
FROM odds FROM odds
WHERE is_active = true AND source = 'b365api'; WHERE is_active = true
AND source = 'b365api';
-- name: GetRawOddsByID :one -- name: GetRawOddsByMarketID :many
SELECT SELECT id,
id, raw_odds,
raw_odds,
fetched_at fetched_at
FROM odds FROM odds
WHERE WHERE market_id = $1
raw_odds @> $1::jsonb AND AND fi = $2
is_active = true AND AND is_active = true
source = 'b365api' AND source = 'b365api'
LIMIT 1; LIMIT $3 OFFSET $4;
-- name: GetPrematchOddsByUpcomingID :many -- name: GetPrematchOddsByUpcomingID :many
SELECT SELECT o.event_id,
o.event_id,
o.fi, o.fi,
o.market_type, o.market_type,
o.market_name, o.market_name,
@ -100,10 +110,10 @@ SELECT
o.source, o.source,
o.is_active o.is_active
FROM odds o FROM odds o
JOIN events e ON o.fi = e.id JOIN events e ON o.fi = e.id
WHERE e.id = $1 WHERE e.id = $1
AND e.is_live = false AND e.is_live = false
AND e.status = 'upcoming' AND e.status = 'upcoming'
AND o.is_active = true AND o.is_active = true
AND o.source = 'b365api' AND o.source = 'b365api'
LIMIT $2 OFFSET $3; LIMIT $2 OFFSET $3;

103
docs/docs.go
View File

@ -1398,50 +1398,6 @@ const docTemplate = `{
} }
} }
}, },
"/prematch/odds/raw/{raw_odds_id}": {
"get": {
"description": "Retrieve raw odds by raw odds ID",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"prematch"
],
"summary": "Retrieve raw odds by ID",
"parameters": [
{
"type": "string",
"description": "Raw Odds ID",
"name": "raw_odds_id",
"in": "path",
"required": true
}
],
"responses": {
"200": {
"description": "OK",
"schema": {
"$ref": "#/definitions/domain.RawOddsByID"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/response.APIResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/response.APIResponse"
}
}
}
}
},
"/prematch/odds/upcoming/{upcoming_id}": { "/prematch/odds/upcoming/{upcoming_id}": {
"get": { "get": {
"description": "Retrieve prematch odds by upcoming event ID (FI from Bet365) with optional pagination", "description": "Retrieve prematch odds by upcoming event ID (FI from Bet365) with optional pagination",
@ -1501,6 +1457,60 @@ const docTemplate = `{
} }
} }
}, },
"/prematch/odds/upcoming/{upcoming_id}/market/{market_id}": {
"get": {
"description": "Retrieve raw odds records using a Market ID",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"prematch"
],
"summary": "Retrieve raw odds by Market ID",
"parameters": [
{
"type": "string",
"description": "Upcoming ID",
"name": "upcoming_id",
"in": "path",
"required": true
},
{
"type": "string",
"description": "Market ID",
"name": "market_id",
"in": "path",
"required": true
}
],
"responses": {
"200": {
"description": "OK",
"schema": {
"type": "array",
"items": {
"$ref": "#/definitions/domain.RawOddsByMarketID"
}
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/response.APIResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/response.APIResponse"
}
}
}
}
},
"/prematch/odds/{event_id}": { "/prematch/odds/{event_id}": {
"get": { "get": {
"description": "Retrieve prematch odds for a specific event by event ID", "description": "Retrieve prematch odds for a specific event by event ID",
@ -2748,12 +2758,9 @@ const docTemplate = `{
"BANK" "BANK"
] ]
}, },
"domain.RawOddsByID": { "domain.RawOddsByMarketID": {
"type": "object", "type": "object",
"properties": { "properties": {
"event_id": {
"type": "string"
},
"fetched_at": { "fetched_at": {
"type": "string" "type": "string"
}, },

103
docs/swagger.json
View File

@ -1390,50 +1390,6 @@
} }
} }
}, },
"/prematch/odds/raw/{raw_odds_id}": {
"get": {
"description": "Retrieve raw odds by raw odds ID",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"prematch"
],
"summary": "Retrieve raw odds by ID",
"parameters": [
{
"type": "string",
"description": "Raw Odds ID",
"name": "raw_odds_id",
"in": "path",
"required": true
}
],
"responses": {
"200": {
"description": "OK",
"schema": {
"$ref": "#/definitions/domain.RawOddsByID"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/response.APIResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/response.APIResponse"
}
}
}
}
},
"/prematch/odds/upcoming/{upcoming_id}": { "/prematch/odds/upcoming/{upcoming_id}": {
"get": { "get": {
"description": "Retrieve prematch odds by upcoming event ID (FI from Bet365) with optional pagination", "description": "Retrieve prematch odds by upcoming event ID (FI from Bet365) with optional pagination",
@ -1493,6 +1449,60 @@
} }
} }
}, },
"/prematch/odds/upcoming/{upcoming_id}/market/{market_id}": {
"get": {
"description": "Retrieve raw odds records using a Market ID",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"prematch"
],
"summary": "Retrieve raw odds by Market ID",
"parameters": [
{
"type": "string",
"description": "Upcoming ID",
"name": "upcoming_id",
"in": "path",
"required": true
},
{
"type": "string",
"description": "Market ID",
"name": "market_id",
"in": "path",
"required": true
}
],
"responses": {
"200": {
"description": "OK",
"schema": {
"type": "array",
"items": {
"$ref": "#/definitions/domain.RawOddsByMarketID"
}
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/response.APIResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/response.APIResponse"
}
}
}
}
},
"/prematch/odds/{event_id}": { "/prematch/odds/{event_id}": {
"get": { "get": {
"description": "Retrieve prematch odds for a specific event by event ID", "description": "Retrieve prematch odds for a specific event by event ID",
@ -2740,12 +2750,9 @@
"BANK" "BANK"
] ]
}, },
"domain.RawOddsByID": { "domain.RawOddsByMarketID": {
"type": "object", "type": "object",
"properties": { "properties": {
"event_id": {
"type": "string"
},
"fetched_at": { "fetched_at": {
"type": "string" "type": "string"
}, },

69
docs/swagger.yaml
View File

@ -93,10 +93,8 @@ definitions:
- TELEBIRR_TRANSACTION - TELEBIRR_TRANSACTION
- ARIFPAY_TRANSACTION - ARIFPAY_TRANSACTION
- BANK - BANK
domain.RawOddsByID: domain.RawOddsByMarketID:
properties: properties:
event_id:
type: string
fetched_at: fetched_at:
type: string type: string
id: id:
@ -1829,35 +1827,6 @@ paths:
summary: Retrieve prematch odds for an event summary: Retrieve prematch odds for an event
tags: tags:
- prematch - prematch
/prematch/odds/raw/{raw_odds_id}:
get:
consumes:
- application/json
description: Retrieve raw odds by raw odds ID
parameters:
- description: Raw Odds ID
in: path
name: raw_odds_id
required: true
type: string
produces:
- application/json
responses:
"200":
description: OK
schema:
$ref: '#/definitions/domain.RawOddsByID'
"400":
description: Bad Request
schema:
$ref: '#/definitions/response.APIResponse'
"500":
description: Internal Server Error
schema:
$ref: '#/definitions/response.APIResponse'
summary: Retrieve raw odds by ID
tags:
- prematch
/prematch/odds/upcoming/{upcoming_id}: /prematch/odds/upcoming/{upcoming_id}:
get: get:
consumes: consumes:
@ -1898,6 +1867,42 @@ paths:
summary: Retrieve prematch odds by upcoming ID (FI) summary: Retrieve prematch odds by upcoming ID (FI)
tags: tags:
- prematch - prematch
/prematch/odds/upcoming/{upcoming_id}/market/{market_id}:
get:
consumes:
- application/json
description: Retrieve raw odds records using a Market ID
parameters:
- description: Upcoming ID
in: path
name: upcoming_id
required: true
type: string
- description: Market ID
in: path
name: market_id
required: true
type: string
produces:
- application/json
responses:
"200":
description: OK
schema:
items:
$ref: '#/definitions/domain.RawOddsByMarketID'
type: array
"400":
description: Bad Request
schema:
$ref: '#/definitions/response.APIResponse'
"500":
description: Internal Server Error
schema:
$ref: '#/definitions/response.APIResponse'
summary: Retrieve raw odds by Market ID
tags:
- prematch
/search/branch: /search/branch:
get: get:
consumes: consumes:

151
gen/db/odds.sql.go
View File

@ -12,8 +12,7 @@ import (
) )
const GetALLPrematchOdds = `-- name: GetALLPrematchOdds :many const GetALLPrematchOdds = `-- name: GetALLPrematchOdds :many
SELECT SELECT event_id,
event_id,
fi, fi,
market_type, market_type,
market_name, market_name,
@ -29,7 +28,8 @@ SELECT
source, source,
is_active is_active
FROM odds FROM odds
WHERE is_active = true AND source = 'b365api' WHERE is_active = true
AND source = 'b365api'
` `
type GetALLPrematchOddsRow struct { type GetALLPrematchOddsRow struct {
@ -87,8 +87,7 @@ func (q *Queries) GetALLPrematchOdds(ctx context.Context) ([]GetALLPrematchOddsR
} }
const GetPrematchOdds = `-- name: GetPrematchOdds :many const GetPrematchOdds = `-- name: GetPrematchOdds :many
SELECT SELECT event_id,
event_id,
fi, fi,
market_type, market_type,
market_name, market_name,
@ -104,7 +103,8 @@ SELECT
source, source,
is_active is_active
FROM odds FROM odds
WHERE is_active = true AND source = 'b365api' WHERE is_active = true
AND source = 'b365api'
` `
type GetPrematchOddsRow struct { type GetPrematchOddsRow struct {
@ -162,8 +162,7 @@ func (q *Queries) GetPrematchOdds(ctx context.Context) ([]GetPrematchOddsRow, er
} }
const GetPrematchOddsByUpcomingID = `-- name: GetPrematchOddsByUpcomingID :many const GetPrematchOddsByUpcomingID = `-- name: GetPrematchOddsByUpcomingID :many
SELECT SELECT o.event_id,
o.event_id,
o.fi, o.fi,
o.market_type, o.market_type,
o.market_name, o.market_name,
@ -179,12 +178,12 @@ SELECT
o.source, o.source,
o.is_active o.is_active
FROM odds o FROM odds o
JOIN events e ON o.fi = e.id JOIN events e ON o.fi = e.id
WHERE e.id = $1 WHERE e.id = $1
AND e.is_live = false AND e.is_live = false
AND e.status = 'upcoming' AND e.status = 'upcoming'
AND o.is_active = true AND o.is_active = true
AND o.source = 'b365api' AND o.source = 'b365api'
LIMIT $2 OFFSET $3 LIMIT $2 OFFSET $3
` `
@ -248,63 +247,103 @@ func (q *Queries) GetPrematchOddsByUpcomingID(ctx context.Context, arg GetPremat
return items, nil return items, nil
} }
const GetRawOddsByID = `-- name: GetRawOddsByID :one const GetRawOddsByMarketID = `-- name: GetRawOddsByMarketID :many
SELECT SELECT id,
id, raw_odds,
raw_odds,
fetched_at fetched_at
FROM odds FROM odds
WHERE WHERE market_id = $1
raw_odds @> $1::jsonb AND AND fi = $2
is_active = true AND AND is_active = true
source = 'b365api' AND source = 'b365api'
LIMIT 1 LIMIT $3 OFFSET $4
` `
type GetRawOddsByIDRow struct { type GetRawOddsByMarketIDParams struct {
MarketID pgtype.Text `json:"market_id"`
Fi pgtype.Text `json:"fi"`
Limit int32 `json:"limit"`
Offset int32 `json:"offset"`
}
type GetRawOddsByMarketIDRow struct {
ID int32 `json:"id"` ID int32 `json:"id"`
RawOdds []byte `json:"raw_odds"` RawOdds []byte `json:"raw_odds"`
FetchedAt pgtype.Timestamp `json:"fetched_at"` FetchedAt pgtype.Timestamp `json:"fetched_at"`
} }
func (q *Queries) GetRawOddsByID(ctx context.Context, dollar_1 []byte) (GetRawOddsByIDRow, error) { func (q *Queries) GetRawOddsByMarketID(ctx context.Context, arg GetRawOddsByMarketIDParams) ([]GetRawOddsByMarketIDRow, error) {
row := q.db.QueryRow(ctx, GetRawOddsByID, dollar_1) rows, err := q.db.Query(ctx, GetRawOddsByMarketID,
var i GetRawOddsByIDRow arg.MarketID,
err := row.Scan(&i.ID, &i.RawOdds, &i.FetchedAt) arg.Fi,
return i, err arg.Limit,
arg.Offset,
)
if err != nil {
return nil, err
}
defer rows.Close()
var items []GetRawOddsByMarketIDRow
for rows.Next() {
var i GetRawOddsByMarketIDRow
if err := rows.Scan(&i.ID, &i.RawOdds, &i.FetchedAt); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
} }
const InsertNonLiveOdd = `-- name: InsertNonLiveOdd :exec const InsertNonLiveOdd = `-- name: InsertNonLiveOdd :exec
INSERT INTO odds ( INSERT INTO odds (
event_id, event_id,
fi, fi,
market_type, market_type,
market_name, market_name,
market_category, market_category,
market_id, market_id,
name, name,
handicap, handicap,
odds_value, odds_value,
section, section,
category, category,
raw_odds, raw_odds,
is_active, is_active,
source, source,
fetched_at fetched_at
) VALUES ( )
$1, $2, $3, $4, $5, $6, $7, VALUES (
$8, $9, $10, $11, $12, $13, $14, $15 $1,
) $2,
ON CONFLICT (market_id, name, handicap) DO UPDATE SET $3,
odds_value = EXCLUDED.odds_value, $4,
raw_odds = EXCLUDED.raw_odds, $5,
market_type = EXCLUDED.market_type, $6,
market_name = EXCLUDED.market_name, $7,
$8,
$9,
$10,
$11,
$12,
$13,
$14,
$15
) ON CONFLICT (event_id, market_id) DO
UPDATE
SET odds_value = EXCLUDED.odds_value,
raw_odds = EXCLUDED.raw_odds,
market_type = EXCLUDED.market_type,
market_name = EXCLUDED.market_name,
market_category = EXCLUDED.market_category, market_category = EXCLUDED.market_category,
fetched_at = EXCLUDED.fetched_at, name = EXCLUDED.name,
is_active = EXCLUDED.is_active, handicap = EXCLUDED.handicap,
source = EXCLUDED.source, fetched_at = EXCLUDED.fetched_at,
fi = EXCLUDED.fi is_active = EXCLUDED.is_active,
source = EXCLUDED.source,
fi = EXCLUDED.fi
` `
type InsertNonLiveOddParams struct { type InsertNonLiveOddParams struct {

9
internal/domain/odds.go
View File

@ -38,9 +38,8 @@ type Odd struct {
Source string `json:"source"` Source string `json:"source"`
IsActive bool `json:"is_active"` IsActive bool `json:"is_active"`
} }
type RawOddsByID struct { type RawOddsByMarketID struct {
ID int64 `json:"id"` ID int64 `json:"id"`
EventID string `json:"event_id"` RawOdds []RawMessage `json:"raw_odds"`
RawOdds []RawMessage `json:"raw_odds"` FetchedAt time.Time `json:"fetched_at"`
FetchedAt time.Time `json:"fetched_at"`
} }

408
internal/repository/odds.go
View File

@ -1,246 +1,256 @@
package repository package repository
import ( import (
"context" "context"
"encoding/json" "encoding/json"
"os" "fmt"
"strconv" "os"
"time" "strconv"
"time"
dbgen "github.com/SamuelTariku/FortuneBet-Backend/gen/db" dbgen "github.com/SamuelTariku/FortuneBet-Backend/gen/db"
"github.com/SamuelTariku/FortuneBet-Backend/internal/domain" "github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
"github.com/jackc/pgx/v5/pgtype" "github.com/jackc/pgx/v5/pgtype"
) )
func (s *Store) SaveNonLiveMarket(ctx context.Context, m domain.Market) error { func (s *Store) SaveNonLiveMarket(ctx context.Context, m domain.Market) error {
if len(m.Odds) == 0 { if len(m.Odds) == 0 {
return nil return nil
} }
for _, raw := range m.Odds { for _, raw := range m.Odds {
var item map[string]interface{} var item map[string]interface{}
if err := json.Unmarshal(raw, &item); err != nil { if err := json.Unmarshal(raw, &item); err != nil {
continue continue
} }
name := getString(item["name"]) name := getString(item["name"])
handicap := getString(item["handicap"]) handicap := getString(item["handicap"])
oddsVal := getFloat(item["odds"]) oddsVal := getFloat(item["odds"])
rawOddsBytes, _ := json.Marshal(m.Odds) rawOddsBytes, _ := json.Marshal(m.Odds)
params := dbgen.InsertNonLiveOddParams{ params := dbgen.InsertNonLiveOddParams{
EventID: pgtype.Text{String: m.EventID, Valid: m.EventID != ""}, EventID: pgtype.Text{String: m.EventID, Valid: m.EventID != ""},
Fi: pgtype.Text{String: m.FI, Valid: m.FI != ""}, Fi: pgtype.Text{String: m.FI, Valid: m.FI != ""},
MarketType: m.MarketType, MarketType: m.MarketType,
MarketName: pgtype.Text{String: m.MarketName, Valid: m.MarketName != ""}, MarketName: pgtype.Text{String: m.MarketName, Valid: m.MarketName != ""},
MarketCategory: pgtype.Text{String: m.MarketCategory, Valid: m.MarketCategory != ""}, MarketCategory: pgtype.Text{String: m.MarketCategory, Valid: m.MarketCategory != ""},
MarketID: pgtype.Text{String: m.MarketID, Valid: m.MarketID != ""}, MarketID: pgtype.Text{String: m.MarketID, Valid: m.MarketID != ""},
Name: pgtype.Text{String: name, Valid: name != ""}, Name: pgtype.Text{String: name, Valid: name != ""},
Handicap: pgtype.Text{String: handicap, Valid: handicap != ""}, Handicap: pgtype.Text{String: handicap, Valid: handicap != ""},
OddsValue: pgtype.Float8{Float64: oddsVal, Valid: oddsVal != 0}, OddsValue: pgtype.Float8{Float64: oddsVal, Valid: oddsVal != 0},
Section: m.MarketCategory, Section: m.MarketCategory,
Category: pgtype.Text{Valid: false}, Category: pgtype.Text{Valid: false},
RawOdds: rawOddsBytes, RawOdds: rawOddsBytes,
IsActive: pgtype.Bool{Bool: true, Valid: true}, IsActive: pgtype.Bool{Bool: true, Valid: true},
Source: pgtype.Text{String: "b365api", Valid: true}, Source: pgtype.Text{String: "b365api", Valid: true},
FetchedAt: pgtype.Timestamp{Time: time.Now(), Valid: true}, FetchedAt: pgtype.Timestamp{Time: time.Now(), Valid: true},
} }
err := s.queries.InsertNonLiveOdd(ctx, params) err := s.queries.InsertNonLiveOdd(ctx, params)
if err != nil { if err != nil {
_ = writeFailedMarketLog(m, err) _ = writeFailedMarketLog(m, err)
continue continue
} }
} }
return nil return nil
} }
func writeFailedMarketLog(m domain.Market, err error) error { func writeFailedMarketLog(m domain.Market, err error) error {
logDir := "logs" logDir := "logs"
logFile := logDir + "/failed_markets.log" logFile := logDir + "/failed_markets.log"
if mkErr := os.MkdirAll(logDir, 0755); mkErr != nil { if mkErr := os.MkdirAll(logDir, 0755); mkErr != nil {
return mkErr return mkErr
} }
f, fileErr := os.OpenFile(logFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644) f, fileErr := os.OpenFile(logFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if fileErr != nil { if fileErr != nil {
return fileErr return fileErr
} }
defer f.Close() defer f.Close()
entry := struct { entry := struct {
Time string `json:"time"` Time string `json:"time"`
Error string `json:"error"` Error string `json:"error"`
Record domain.Market `json:"record"` Record domain.Market `json:"record"`
}{ }{
Time: time.Now().Format(time.RFC3339), Time: time.Now().Format(time.RFC3339),
Error: err.Error(), Error: err.Error(),
Record: m, Record: m,
} }
jsonData, _ := json.MarshalIndent(entry, "", " ") jsonData, _ := json.MarshalIndent(entry, "", " ")
_, writeErr := f.WriteString(string(jsonData) + "\n\n") _, writeErr := f.WriteString(string(jsonData) + "\n\n")
return writeErr return writeErr
} }
func getString(v interface{}) string { func getString(v interface{}) string {
if s, ok := v.(string); ok { if s, ok := v.(string); ok {
return s return s
} }
return "" return ""
} }
func getFloat(v interface{}) float64 { func getFloat(v interface{}) float64 {
if s, ok := v.(string); ok { if s, ok := v.(string); ok {
f, err := strconv.ParseFloat(s, 64) f, err := strconv.ParseFloat(s, 64)
if err == nil { if err == nil {
return f return f
} }
} }
return 0 return 0
} }
func (s *Store) GetPrematchOdds(ctx context.Context, eventID string) ([]domain.Odd, error) { func (s *Store) GetPrematchOdds(ctx context.Context, eventID string) ([]domain.Odd, error) {
odds, err := s.queries.GetPrematchOdds(ctx) odds, err := s.queries.GetPrematchOdds(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
domainOdds := make([]domain.Odd, len(odds)) domainOdds := make([]domain.Odd, len(odds))
for i, odd := range odds { for i, odd := range odds {
domainOdds[i] = domain.Odd{ domainOdds[i] = domain.Odd{
EventID: odd.EventID.String, EventID: odd.EventID.String,
Fi: odd.Fi.String, Fi: odd.Fi.String,
MarketType: odd.MarketType, MarketType: odd.MarketType,
MarketName: odd.MarketName.String, MarketName: odd.MarketName.String,
MarketCategory: odd.MarketCategory.String, MarketCategory: odd.MarketCategory.String,
MarketID: odd.MarketID.String, MarketID: odd.MarketID.String,
Name: odd.Name.String, Name: odd.Name.String,
Handicap: odd.Handicap.String, Handicap: odd.Handicap.String,
OddsValue: odd.OddsValue.Float64, OddsValue: odd.OddsValue.Float64,
Section: odd.Section, Section: odd.Section,
Category: odd.Category.String, Category: odd.Category.String,
RawOdds: func() []domain.RawMessage { RawOdds: func() []domain.RawMessage {
var rawOdds []domain.RawMessage var rawOdds []domain.RawMessage
if err := json.Unmarshal(odd.RawOdds, &rawOdds); err != nil { if err := json.Unmarshal(odd.RawOdds, &rawOdds); err != nil {
rawOdds = nil rawOdds = nil
} }
return rawOdds return rawOdds
}(), }(),
FetchedAt: odd.FetchedAt.Time, FetchedAt: odd.FetchedAt.Time,
Source: odd.Source.String, Source: odd.Source.String,
IsActive: odd.IsActive.Bool, IsActive: odd.IsActive.Bool,
} }
} }
return domainOdds, nil return domainOdds, nil
} }
func (s *Store) GetALLPrematchOdds(ctx context.Context) ([]domain.Odd, error) { func (s *Store) GetALLPrematchOdds(ctx context.Context) ([]domain.Odd, error) {
rows, err := s.queries.GetALLPrematchOdds(ctx) rows, err := s.queries.GetALLPrematchOdds(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
domainOdds := make([]domain.Odd, len(rows)) domainOdds := make([]domain.Odd, len(rows))
for i, row := range rows { for i, row := range rows {
domainOdds[i] = domain.Odd{ domainOdds[i] = domain.Odd{
// ID: int64(row.ID), // ID: int64(row.ID),
EventID: row.EventID.String, EventID: row.EventID.String,
Fi: row.Fi.String, Fi: row.Fi.String,
MarketType: row.MarketType, MarketType: row.MarketType,
MarketName: row.MarketName.String, MarketName: row.MarketName.String,
MarketCategory: row.MarketCategory.String, MarketCategory: row.MarketCategory.String,
MarketID: row.MarketID.String, MarketID: row.MarketID.String,
Name: row.Name.String, Name: row.Name.String,
Handicap: row.Handicap.String, Handicap: row.Handicap.String,
OddsValue: row.OddsValue.Float64, OddsValue: row.OddsValue.Float64,
Section: row.Section, Section: row.Section,
Category: row.Category.String, Category: row.Category.String,
RawOdds: func() []domain.RawMessage { RawOdds: func() []domain.RawMessage {
var rawOdds []domain.RawMessage var rawOdds []domain.RawMessage
if err := json.Unmarshal(row.RawOdds, &rawOdds); err != nil { if err := json.Unmarshal(row.RawOdds, &rawOdds); err != nil {
rawOdds = nil rawOdds = nil
} }
return rawOdds return rawOdds
}(), }(),
FetchedAt: row.FetchedAt.Time, FetchedAt: row.FetchedAt.Time,
Source: row.Source.String, Source: row.Source.String,
IsActive: row.IsActive.Bool, IsActive: row.IsActive.Bool,
} }
} }
return domainOdds, nil return domainOdds, nil
} }
func (s *Store) GetRawOddsByID(ctx context.Context, rawOddsID string) (domain.RawOddsByID, error) { func (s *Store) GetRawOddsByMarketID(ctx context.Context, rawOddsID string, upcomingID string) (domain.RawOddsByMarketID, error) {
jsonFilter := `[{"id":"` + rawOddsID + `"}]` params := dbgen.GetRawOddsByMarketIDParams{
MarketID: pgtype.Text{String: rawOddsID, Valid: true},
Fi: pgtype.Text{String: upcomingID, Valid: true},
Limit: 1,
Offset: 0,
}
odd, err := s.queries.GetRawOddsByID(ctx, []byte(jsonFilter)) rows, err := s.queries.GetRawOddsByMarketID(ctx, params)
if err != nil { if err != nil {
return domain.RawOddsByID{}, err return domain.RawOddsByMarketID{}, err
} }
var rawOdds []json.RawMessage if len(rows) == 0 {
if err := json.Unmarshal(odd.RawOdds, &rawOdds); err != nil { return domain.RawOddsByMarketID{}, fmt.Errorf("no raw odds found for market_id: %s", rawOddsID)
return domain.RawOddsByID{}, err }
}
return domain.RawOddsByID{ row := rows[0]
ID: int64(odd.ID),
RawOdds: func() []domain.RawMessage { var rawOdds []json.RawMessage
converted := make([]domain.RawMessage, len(rawOdds)) if err := json.Unmarshal(row.RawOdds, &rawOdds); err != nil {
for i, r := range rawOdds { return domain.RawOddsByMarketID{}, err
converted[i] = domain.RawMessage(r) }
}
return converted return domain.RawOddsByMarketID{
}(), ID: int64(row.ID),
FetchedAt: odd.FetchedAt.Time, RawOdds: func() []domain.RawMessage {
}, nil converted := make([]domain.RawMessage, len(rawOdds))
for i, r := range rawOdds {
converted[i] = domain.RawMessage(r)
}
return converted
}(),
FetchedAt: row.FetchedAt.Time,
}, nil
} }
func (s *Store) GetPrematchOddsByUpcomingID(ctx context.Context, upcomingID string, limit, offset int32) ([]domain.Odd, error) { func (s *Store) GetPrematchOddsByUpcomingID(ctx context.Context, upcomingID string, limit, offset int32) ([]domain.Odd, error) {
// Prepare query parameters params := dbgen.GetPrematchOddsByUpcomingIDParams{
params := dbgen.GetPrematchOddsByUpcomingIDParams{ ID: upcomingID,
ID: upcomingID, Limit: limit,
Limit: limit, Offset: offset,
Offset: offset, }
}
// Execute the query odds, err := s.queries.GetPrematchOddsByUpcomingID(ctx, params)
odds, err := s.queries.GetPrematchOddsByUpcomingID(ctx, params) if err != nil {
if err != nil { return nil, err
return nil, err }
}
// Map the results to domain.Odd // Map the results to domain.Odd
domainOdds := make([]domain.Odd, len(odds)) domainOdds := make([]domain.Odd, len(odds))
for i, odd := range odds { for i, odd := range odds {
var rawOdds []domain.RawMessage var rawOdds []domain.RawMessage
if err := json.Unmarshal(odd.RawOdds, &rawOdds); err != nil { if err := json.Unmarshal(odd.RawOdds, &rawOdds); err != nil {
rawOdds = nil rawOdds = nil
} }
domainOdds[i] = domain.Odd{ domainOdds[i] = domain.Odd{
EventID: odd.EventID.String, EventID: odd.EventID.String,
Fi: odd.Fi.String, Fi: odd.Fi.String,
MarketType: odd.MarketType, MarketType: odd.MarketType,
MarketName: odd.MarketName.String, MarketName: odd.MarketName.String,
MarketCategory: odd.MarketCategory.String, MarketCategory: odd.MarketCategory.String,
MarketID: odd.MarketID.String, MarketID: odd.MarketID.String,
Name: odd.Name.String, Name: odd.Name.String,
Handicap: odd.Handicap.String, Handicap: odd.Handicap.String,
OddsValue: odd.OddsValue.Float64, OddsValue: odd.OddsValue.Float64,
Section: odd.Section, Section: odd.Section,
Category: odd.Category.String, Category: odd.Category.String,
RawOdds: rawOdds, RawOdds: rawOdds,
FetchedAt: odd.FetchedAt.Time, FetchedAt: odd.FetchedAt.Time,
Source: odd.Source.String, Source: odd.Source.String,
IsActive: odd.IsActive.Bool, IsActive: odd.IsActive.Bool,
} }
} }
return domainOdds, nil return domainOdds, nil
} }

4
internal/services/odds/port.go
View File

@ -10,7 +10,5 @@ type Service interface {
FetchNonLiveOdds(ctx context.Context) error FetchNonLiveOdds(ctx context.Context) error
GetPrematchOdds(ctx context.Context, eventID string) ([]domain.Odd, error) GetPrematchOdds(ctx context.Context, eventID string) ([]domain.Odd, error)
GetALLPrematchOdds(ctx context.Context) ([]domain.Odd, error) GetALLPrematchOdds(ctx context.Context) ([]domain.Odd, error)
GetRawOddsByID(ctx context.Context, rawOddsID string) ([]domain.RawOddsByID, error) GetRawOddsByMarketID(ctx context.Context, marketID string, upcomingID string) ([]domain.RawOddsByMarketID, error)
} }

89
internal/services/odds/service.go
View File

@ -22,7 +22,6 @@ func New(token string, store *repository.Store) *ServiceImpl {
return &ServiceImpl{token: token, store: store} return &ServiceImpl{token: token, store: store}
} }
func (s *ServiceImpl) FetchNonLiveOdds(ctx context.Context) error { func (s *ServiceImpl) FetchNonLiveOdds(ctx context.Context) error {
eventIDs, err := s.store.GetAllUpcomingEvents(ctx) eventIDs, err := s.store.GetAllUpcomingEvents(ctx)
if err != nil { if err != nil {
@ -30,43 +29,43 @@ func (s *ServiceImpl) FetchNonLiveOdds(ctx context.Context) error {
return err return err
} }
for _, event := range eventIDs { for _, event := range eventIDs {
eventID := event.ID eventID := event.ID
prematchURL := "https://api.b365api.com/v3/bet365/prematch?token=" + s.token + "&FI=" + eventID prematchURL := "https://api.b365api.com/v3/bet365/prematch?token=" + s.token + "&FI=" + eventID
log.Printf("📡 Fetching prematch odds for event ID: %s", eventID) log.Printf("📡 Fetching prematch odds for event ID: %s", eventID)
resp, err := http.Get(prematchURL) resp, err := http.Get(prematchURL)
if err != nil { if err != nil {
log.Printf("❌ Failed to fetch prematch odds for event %s: %v", eventID, err) log.Printf("❌ Failed to fetch prematch odds for event %s: %v", eventID, err)
continue continue
} }
defer resp.Body.Close() defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body) body, _ := io.ReadAll(resp.Body)
var oddsData struct { var oddsData struct {
Success int `json:"success"` Success int `json:"success"`
Results []struct { Results []struct {
EventID string `json:"event_id"` EventID string `json:"event_id"`
FI string `json:"FI"` FI string `json:"FI"`
Main OddsSection `json:"main"` Main OddsSection `json:"main"`
} `json:"results"` } `json:"results"`
} }
if err := json.Unmarshal(body, &oddsData); err != nil || oddsData.Success != 1 || len(oddsData.Results) == 0 { if err := json.Unmarshal(body, &oddsData); err != nil || oddsData.Success != 1 || len(oddsData.Results) == 0 {
log.Printf("❌ Invalid prematch data for event %s", eventID) log.Printf("❌ Invalid prematch data for event %s", eventID)
continue continue
} }
result := oddsData.Results[0] result := oddsData.Results[0]
finalID := result.EventID finalID := result.EventID
if finalID == "" { if finalID == "" {
finalID = result.FI finalID = result.FI
} }
if finalID == "" { if finalID == "" {
log.Printf("⚠️ Skipping event %s with no valid ID", eventID) log.Printf("⚠️ Skipping event %s with no valid ID", eventID)
continue continue
} }
s.storeSection(ctx, finalID, result.FI, "main", result.Main) s.storeSection(ctx, finalID, result.FI, "main", result.Main)
} }
return nil return nil
} }
@ -108,12 +107,10 @@ type OddsMarket struct {
} }
type OddsSection struct { type OddsSection struct {
UpdatedAt string `json:"updated_at"` UpdatedAt string `json:"updated_at"`
Sp map[string]OddsMarket `json:"sp"` Sp map[string]OddsMarket `json:"sp"`
} }
func (s *ServiceImpl) GetPrematchOdds(ctx context.Context, eventID string) ([]domain.Odd, error) { func (s *ServiceImpl) GetPrematchOdds(ctx context.Context, eventID string) ([]domain.Odd, error) {
return s.store.GetPrematchOdds(ctx, eventID) return s.store.GetPrematchOdds(ctx, eventID)
} }
@ -122,13 +119,15 @@ func (s *ServiceImpl) GetALLPrematchOdds(ctx context.Context) ([]domain.Odd, err
return s.store.GetALLPrematchOdds(ctx) return s.store.GetALLPrematchOdds(ctx)
} }
func (s *ServiceImpl) GetRawOddsByID(ctx context.Context, rawOddsID string) ([]domain.RawOddsByID, error) { func (s *ServiceImpl) GetRawOddsByMarketID(ctx context.Context, marketID string, upcomingID string) ([]domain.RawOddsByMarketID, error) {
rawOdds, err := s.store.GetRawOddsByID(ctx, rawOddsID) rows, err := s.store.GetRawOddsByMarketID(ctx, marketID, upcomingID)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return []domain.RawOddsByID{rawOdds}, nil
return []domain.RawOddsByMarketID{rows}, nil
} }
func (s *ServiceImpl) GetPrematchOddsByUpcomingID(ctx context.Context, upcomingID string, limit, offset int32) ([]domain.Odd, error) { func (s *ServiceImpl) GetPrematchOddsByUpcomingID(ctx context.Context, upcomingID string, limit, offset int32) ([]domain.Odd, error) {
return s.store.GetPrematchOddsByUpcomingID(ctx, upcomingID, limit, offset) return s.store.GetPrematchOddsByUpcomingID(ctx, upcomingID, limit, offset)
} }

4
internal/web_server/cron.go
View File

@ -1,6 +1,8 @@
package httpserver package httpserver
import ( import (
// "context"
"log" "log"
eventsvc "github.com/SamuelTariku/FortuneBet-Backend/internal/services/event" eventsvc "github.com/SamuelTariku/FortuneBet-Backend/internal/services/event"
@ -35,7 +37,7 @@ func StartDataFetchingCrons(eventService eventsvc.Service, oddsService oddssvc.S
// }, // },
// { // {
// spec: "*/30 * * * * *", // Every 30 seconds // spec: "*/5 * * * * *", // Every 5 seconds
// task: func() { // task: func() {
// if err := oddsService.FetchNonLiveOdds(context.Background()); err != nil { // if err := oddsService.FetchNonLiveOdds(context.Background()); err != nil {
// log.Printf("FetchNonLiveOdds error: %v", err) // log.Printf("FetchNonLiveOdds error: %v", err)

160
internal/web_server/handlers/prematch.go
View File

@ -22,21 +22,22 @@ import (
// @Failure 500 {object} response.APIResponse // @Failure 500 {object} response.APIResponse
// @Router /prematch/odds/{event_id} [get] // @Router /prematch/odds/{event_id} [get]
func GetPrematchOdds(logger *slog.Logger, prematchSvc *odds.ServiceImpl) fiber.Handler { func GetPrematchOdds(logger *slog.Logger, prematchSvc *odds.ServiceImpl) fiber.Handler {
return func(c *fiber.Ctx) error { return func(c *fiber.Ctx) error {
eventID := c.Params("event_id") eventID := c.Params("event_id")
if eventID == "" { if eventID == "" {
return response.WriteJSON(c, fiber.StatusBadRequest, "Missing event_id", nil, nil) return response.WriteJSON(c, fiber.StatusBadRequest, "Missing event_id", nil, nil)
} }
odds, err := prematchSvc.GetPrematchOdds(c.Context(), eventID) odds, err := prematchSvc.GetPrematchOdds(c.Context(), eventID)
if err != nil { if err != nil {
return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to retrieve odds", nil, nil) return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to retrieve odds", nil, nil)
} }
return response.WriteJSON(c, fiber.StatusOK, "Prematch odds retrieved successfully", odds, nil) return response.WriteJSON(c, fiber.StatusOK, "Prematch odds retrieved successfully", odds, nil)
} }
} }
//GetALLPrematchOdds
// GetALLPrematchOdds
// @Summary Retrieve all prematch odds // @Summary Retrieve all prematch odds
// @Description Retrieve all prematch odds from the database // @Description Retrieve all prematch odds from the database
// @Tags prematch // @Tags prematch
@ -46,40 +47,48 @@ func GetPrematchOdds(logger *slog.Logger, prematchSvc *odds.ServiceImpl) fiber.H
// @Failure 500 {object} response.APIResponse // @Failure 500 {object} response.APIResponse
// @Router /prematch/odds [get] // @Router /prematch/odds [get]
func GetALLPrematchOdds(logger *slog.Logger, prematchSvc *odds.ServiceImpl) fiber.Handler { func GetALLPrematchOdds(logger *slog.Logger, prematchSvc *odds.ServiceImpl) fiber.Handler {
return func(c *fiber.Ctx) error { return func(c *fiber.Ctx) error {
odds, err := prematchSvc.GetALLPrematchOdds(c.Context()) odds, err := prematchSvc.GetALLPrematchOdds(c.Context())
if err != nil { if err != nil {
return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to retrieve all prematch odds", nil, nil) return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to retrieve all prematch odds", nil, nil)
} }
return response.WriteJSON(c, fiber.StatusOK, "All prematch odds retrieved successfully", odds, nil) return response.WriteJSON(c, fiber.StatusOK, "All prematch odds retrieved successfully", odds, nil)
} }
} }
// GetRawOddsByID
// @Summary Retrieve raw odds by ID // GetRawOddsByMarketID
// @Description Retrieve raw odds by raw odds ID // @Summary Retrieve raw odds by Market ID
// @Description Retrieve raw odds records using a Market ID
// @Tags prematch // @Tags prematch
// @Accept json // @Accept json
// @Produce json // @Produce json
// @Param raw_odds_id path string true "Raw Odds ID" // @Param upcoming_id path string true "Upcoming ID"
// @Success 200 {object} domain.RawOddsByID // @Param market_id path string true "Market ID"
// @Success 200 {array} domain.RawOddsByMarketID
// @Failure 400 {object} response.APIResponse // @Failure 400 {object} response.APIResponse
// @Failure 500 {object} response.APIResponse // @Failure 500 {object} response.APIResponse
// @Router /prematch/odds/raw/{raw_odds_id} [get] // @Router /prematch/odds/upcoming/{upcoming_id}/market/{market_id} [get]
func GetRawOddsByID(logger *slog.Logger, prematchSvc *odds.ServiceImpl) fiber.Handler { func GetRawOddsByMarketID(logger *slog.Logger, prematchSvc *odds.ServiceImpl) fiber.Handler {
return func(c *fiber.Ctx) error { return func(c *fiber.Ctx) error {
rawOddsID := c.Params("raw_odds_id") marketID := c.Params("market_id")
if rawOddsID == "" { upcomingID := c.Params("upcoming_id")
return response.WriteJSON(c, fiber.StatusBadRequest, "Missing raw_odds_id", nil, nil) if marketID == "" {
} return response.WriteJSON(c, fiber.StatusBadRequest, "Missing market_id", nil, nil)
}
rawOdds, err := prematchSvc.GetRawOddsByID(c.Context(), rawOddsID) if upcomingID == "" {
if err != nil { return response.WriteJSON(c, fiber.StatusBadRequest, "Missing upcoming_id", nil, nil)
return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to retrieve raw odds", nil, nil) }
}
return response.WriteJSON(c, fiber.StatusOK, "Raw odds retrieved successfully", rawOdds, nil) rawOdds, err := prematchSvc.GetRawOddsByMarketID(c.Context(), marketID, upcomingID)
} if err != nil {
logger.Error("failed to fetch raw odds", "error", err)
return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to retrieve raw odds", err, nil)
}
return response.WriteJSON(c, fiber.StatusOK, "Raw odds retrieved successfully", rawOdds, nil)
}
} }
// @Summary Retrieve all upcoming events // @Summary Retrieve all upcoming events
@ -91,15 +100,16 @@ func GetRawOddsByID(logger *slog.Logger, prematchSvc *odds.ServiceImpl) fiber.Ha
// @Failure 500 {object} response.APIResponse // @Failure 500 {object} response.APIResponse
// @Router /prematch/events [get] // @Router /prematch/events [get]
func GetAllUpcomingEvents(logger *slog.Logger, eventSvc event.Service) fiber.Handler { func GetAllUpcomingEvents(logger *slog.Logger, eventSvc event.Service) fiber.Handler {
return func(c *fiber.Ctx) error { return func(c *fiber.Ctx) error {
events, err := eventSvc.GetAllUpcomingEvents(c.Context()) events, err := eventSvc.GetAllUpcomingEvents(c.Context())
if err != nil { if err != nil {
return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to retrieve all upcoming events", nil, nil) return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to retrieve all upcoming events", nil, nil)
} }
return response.WriteJSON(c, fiber.StatusOK, "All upcoming events retrieved successfully", events, nil) return response.WriteJSON(c, fiber.StatusOK, "All upcoming events retrieved successfully", events, nil)
} }
} }
// @Summary Retrieve an upcoming by ID // @Summary Retrieve an upcoming by ID
// @Description Retrieve an upcoming event by ID // @Description Retrieve an upcoming event by ID
// @Tags prematch // @Tags prematch
@ -111,20 +121,21 @@ func GetAllUpcomingEvents(logger *slog.Logger, eventSvc event.Service) fiber.Han
// @Failure 500 {object} response.APIResponse // @Failure 500 {object} response.APIResponse
// @Router /prematch/events/{id} [get] // @Router /prematch/events/{id} [get]
func GetUpcomingEventByID(logger *slog.Logger, eventSvc event.Service) fiber.Handler { func GetUpcomingEventByID(logger *slog.Logger, eventSvc event.Service) fiber.Handler {
return func(c *fiber.Ctx) error { return func(c *fiber.Ctx) error {
id := c.Params("id") id := c.Params("id")
if id == "" { if id == "" {
return response.WriteJSON(c, fiber.StatusBadRequest, "Missing id", nil, nil) return response.WriteJSON(c, fiber.StatusBadRequest, "Missing id", nil, nil)
} }
event, err := eventSvc.GetUpcomingEventByID(c.Context(), id) event, err := eventSvc.GetUpcomingEventByID(c.Context(), id)
if err != nil { if err != nil {
return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to retrieve upcoming event", nil, nil) return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to retrieve upcoming event", nil, nil)
} }
return response.WriteJSON(c, fiber.StatusOK, "Upcoming event retrieved successfully", event, nil) return response.WriteJSON(c, fiber.StatusOK, "Upcoming event retrieved successfully", event, nil)
} }
} }
// @Summary Retrieve prematch odds by upcoming ID (FI) // @Summary Retrieve prematch odds by upcoming ID (FI)
// @Description Retrieve prematch odds by upcoming event ID (FI from Bet365) with optional pagination // @Description Retrieve prematch odds by upcoming event ID (FI from Bet365) with optional pagination
// @Tags prematch // @Tags prematch
@ -138,28 +149,27 @@ func GetUpcomingEventByID(logger *slog.Logger, eventSvc event.Service) fiber.Han
// @Failure 500 {object} response.APIResponse // @Failure 500 {object} response.APIResponse
// @Router /prematch/odds/upcoming/{upcoming_id} [get] // @Router /prematch/odds/upcoming/{upcoming_id} [get]
func GetPrematchOddsByUpcomingID(logger *slog.Logger, prematchSvc *odds.ServiceImpl) fiber.Handler { func GetPrematchOddsByUpcomingID(logger *slog.Logger, prematchSvc *odds.ServiceImpl) fiber.Handler {
return func(c *fiber.Ctx) error { return func(c *fiber.Ctx) error {
upcomingID := c.Params("upcoming_id") upcomingID := c.Params("upcoming_id")
if upcomingID == "" { if upcomingID == "" {
return response.WriteJSON(c, fiber.StatusBadRequest, "Missing upcoming_id", nil, nil) return response.WriteJSON(c, fiber.StatusBadRequest, "Missing upcoming_id", nil, nil)
} }
limit, err := strconv.Atoi(c.Query("limit", "10")) // Default limit is 10 limit, err := strconv.Atoi(c.Query("limit", "10")) // Default limit is 10
if err != nil || limit <= 0 { if err != nil || limit <= 0 {
return response.WriteJSON(c, fiber.StatusBadRequest, "Invalid limit value", nil, nil) return response.WriteJSON(c, fiber.StatusBadRequest, "Invalid limit value", nil, nil)
} }
offset, err := strconv.Atoi(c.Query("offset", "0")) // Default offset is 0 offset, err := strconv.Atoi(c.Query("offset", "0")) // Default offset is 0
if err != nil || offset < 0 { if err != nil || offset < 0 {
return response.WriteJSON(c, fiber.StatusBadRequest, "Invalid offset value", nil, nil) return response.WriteJSON(c, fiber.StatusBadRequest, "Invalid offset value", nil, nil)
} }
odds, err := prematchSvc.GetPrematchOddsByUpcomingID(c.Context(), upcomingID, int32(limit), int32(offset)) odds, err := prematchSvc.GetPrematchOddsByUpcomingID(c.Context(), upcomingID, int32(limit), int32(offset))
if err != nil { if err != nil {
return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to retrieve prematch odds", nil, nil) return response.WriteJSON(c, fiber.StatusInternalServerError, "Failed to retrieve prematch odds", nil, nil)
} }
return response.WriteJSON(c, fiber.StatusOK, "Prematch odds retrieved successfully", odds, nil) return response.WriteJSON(c, fiber.StatusOK, "Prematch odds retrieved successfully", odds, nil)
} }
} }

2
internal/web_server/routes.go
View File

@ -59,7 +59,7 @@ func (a *App) initAppRoutes() {
a.fiber.Get("/prematch/odds/:event_id", handlers.GetPrematchOdds(a.logger, a.prematchSvc)) a.fiber.Get("/prematch/odds/:event_id", handlers.GetPrematchOdds(a.logger, a.prematchSvc))
a.fiber.Get("/prematch/odds", handlers.GetALLPrematchOdds(a.logger, a.prematchSvc)) a.fiber.Get("/prematch/odds", handlers.GetALLPrematchOdds(a.logger, a.prematchSvc))
a.fiber.Get("/prematch/odds/raw/:raw_odds_id", handlers.GetRawOddsByID(a.logger, a.prematchSvc)) a.fiber.Get("/prematch/odds/upcoming/:upcoming_id/market/:market_id", handlers.GetRawOddsByMarketID(a.logger, a.prematchSvc))
a.fiber.Get("/prematch/events/:id", handlers.GetUpcomingEventByID(a.logger, a.eventSvc)) a.fiber.Get("/prematch/events/:id", handlers.GetUpcomingEventByID(a.logger, a.eventSvc))
a.fiber.Get("/prematch/events", handlers.GetAllUpcomingEvents(a.logger, a.eventSvc)) a.fiber.Get("/prematch/events", handlers.GetAllUpcomingEvents(a.logger, a.eventSvc))