sorare/api.go

137 lines
3.8 KiB
Go

package sorare
import (
"bytes"
"context"
"encoding/json"
"io"
"log"
"net/http"
"github.com/hashicorp/go-retryablehttp"
"git.lehouerou.net/laurent/sorare/config"
"git.lehouerou.net/laurent/sorare/football"
"git.lehouerou.net/laurent/sorare/graphql"
"git.lehouerou.net/laurent/sorare/mutations"
"git.lehouerou.net/laurent/sorare/subscriptions"
"git.lehouerou.net/laurent/sorare/tokens"
"git.lehouerou.net/laurent/sorare/types"
)
const (
baseUrl = "https://api.sorare.com/federation/graphql"
)
type Sorare struct {
httpClient *retryablehttp.Client
Client *graphql.Client
Config *config.Config
Football *football.Football
Users *Users
Country *graphql.Query[Country, graphql.SlugParams]
Countries *graphql.Query[[]Country, graphql.SlugsParams]
Tokens *tokens.Tokens
ShopItems *graphql.PaginatedQuery[ShopItem, ShopItemsParams]
NbaPlayer *graphql.Query[NbaPlayer, graphql.SlugParams]
NbaPlayers *graphql.Query[[]NbaPlayer, graphql.SlugsParams]
Mutations *mutations.Mutations
Subscriptions *subscriptions.Subscriptions
}
func New() *Sorare {
httpClient := retryablehttp.NewClient()
httpClient.Logger = nil
c := graphql.NewClient(httpClient.StandardClient(), baseUrl)
return &Sorare{
httpClient: httpClient,
Client: c,
Config: config.NewConfig(c),
Football: football.NewFootball(c),
Users: NewUsers(c),
Country: graphql.NewQuery[Country, graphql.SlugParams](c, "country", nil),
Countries: graphql.NewQuery[[]Country, graphql.SlugsParams](c, "countries", nil),
Tokens: tokens.NewTokens(c),
ShopItems: graphql.NewPaginatedQuery[ShopItem, ShopItemsParams](c, "shopItems", nil),
NbaPlayer: graphql.NewQuery[NbaPlayer, graphql.SlugParams](c, "nbaPlayer", nil),
NbaPlayers: graphql.NewQuery[[]NbaPlayer, graphql.SlugsParams](c, "nbaPlayers", nil),
Mutations: mutations.NewMutations(c),
Subscriptions: subscriptions.NewSubscriptions(),
}
}
func (s *Sorare) Debug() *Sorare {
s.httpClient.RequestLogHook = func(l retryablehttp.Logger, req *http.Request, attempt int) {
if req.Body != nil {
b, err := io.ReadAll(req.Body)
if err == nil {
req.Body = io.NopCloser(bytes.NewBuffer(b))
}
log.Printf("Request: %s %s\n%s\n", req.Method, req.URL, string(b))
} else {
log.Printf("Request: %s %s\n", req.Method, req.URL)
}
}
s.httpClient.ResponseLogHook = func(l retryablehttp.Logger, resp *http.Response) {
if resp.Body != nil {
b, err := io.ReadAll(resp.Body)
if err == nil {
resp.Body = io.NopCloser(bytes.NewBuffer(b))
}
var jsonbody bytes.Buffer
err = json.Indent(&jsonbody, b, "", " ")
if err == nil {
log.Printf("Response: %s\n%s\n", resp.Status, jsonbody.String())
return
}
log.Printf("Response: %s\n%s\n", resp.Status, string(b))
} else {
log.Printf("Response: %s\n", resp.Status)
}
}
s.Subscriptions.SetDebug(true)
return s
}
func (s *Sorare) SetApiKey(apiKey string) {
s.Client.SetApiKey(apiKey)
}
func (s *Sorare) SetJWTToken(token graphql.JwtToken, audience string) {
s.Client.SetJWTToken(token, audience)
}
func (s *Sorare) GetCurrentToken() graphql.JwtToken {
return s.Client.GetCurrentToken()
}
func (s *Sorare) Authenticate(
ctx context.Context,
email string,
password string,
audience string,
otp string,
) error {
return s.Client.Authenticate(ctx, email, password, audience, otp)
}
func (s *Sorare) Query(
ctx context.Context,
query interface{},
variables map[string]interface{},
) error {
return s.Client.Query(ctx, query, variables)
}
func (s *Sorare) GetRawQuery(query interface{}, variables map[string]interface{}) (string, error) {
return s.Client.ConstructRawQuery(query, variables)
}
func (s *Sorare) SetDefaultSettlementCurrencies(currencies []types.SupportedCurrency) {
s.Mutations.SetDefaultSettlementCurrencies(currencies)
}