Implemented a naive (but working) way to retrieve players from the api.

Author: Homeblest

links/link.go

@@ -0,0 +1,7 @@
+package links
+
+// Link describes the properties of a link object
+type Link struct {
+	Self   string `json:"self"`
+	Schema string `json:"schema,omitempty"`
+}

listing/service.go

@@ -4,7 +4,7 @@ import "github.com/homeblest/pubg_stat_tracker/players"
 
 // Service provides player listing operations
 type Service interface {
-	GetPlayer(string) (players.Player, error)
+	GetPlayer(string) (*players.Player, error)
 }
 
 type service struct {
@@ -17,6 +17,6 @@ func NewService(playerRepo players.Repository) Service {
 }
 
 // GetPlayer returns a player in the playerRepository
-func (s *service) GetPlayer(name string) (players.Player, error) {
+func (s *service) GetPlayer(name string) (*players.Player, error) {
 	return s.playerRepo.Get(name)
 }

main.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"flag"
 	"fmt"
 	"os"
 	"os/signal"
@@ -28,9 +27,8 @@ var requestSvc requesting.Service
 var listingSvc listing.Service
 
 func main() {
-	flag.StringVar(&Token, "t", "", "Bot Token")
-	flag.StringVar(&APIKey, "k", "", "PUBG API Key")
-	flag.Parse()
+	APIKey = os.Getenv("PUBG_API_KEY")
+	Token = os.Getenv("DISCORD_BOT_TOKEN")
 
 	var playerStorage players.Repository
 	var matchStorage matches.Repository
@@ -71,30 +69,21 @@ func messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
 	if m.Author.ID == s.State.User.ID {
 		return
 	}
+	inputString := strings.Split(m.Content, " ")
+	cmd := inputString[0]
 
-	switch {
-	case strings.HasPrefix(m.Content, "!hello"):
+	switch cmd {
+	case "!hello":
 		s.ChannelMessageSend(m.ChannelID, "Hello friend!")
-	case strings.HasPrefix(m.Content, "!stats"):
-		player, err := listingSvc.GetPlayer("Homeblest")
+	case "!stats":
+		name := inputString[1]
 
+		playerPointer, err := requestSvc.RequestPlayer(name, "pc-eu")
 		if err != nil {
-			if err == players.ErrorPlayerNotFound {
-				// Player wasn't found in storage, get him from the API and store him
-				player, err := requestSvc.RequestPlayer("pc-eu", "Homeblest")
-				if err != nil {
-					fmt.Println(err)
-					return
-				}
-				addingSvc.AddPlayer(*player)
-			} else {
-				fmt.Println(err)
-				return
-			}
-
+			fmt.Println(err)
+			return
 		}
-
-		playerString := fmt.Sprintf("I tried contacting the PUBG API, did it work? playerName: %s", player.Name)
+		playerString := fmt.Sprintf("I tried contacting the PUBG API, did it work? playerName: %s", playerPointer.Attributes.Name)
 		s.ChannelMessageSend(m.ChannelID, playerString)
 	}
 

matches/match.go

@@ -2,18 +2,21 @@ package matches
 
 import (
 	"errors"
-	"time"
 )
 
+// Lite describes a list of LiteData match objects
+type Lite struct {
+	Data []LiteData `json:"data"`
+}
+
+// LiteData is a lite version of a match Data object, only containing a type and a match ID each
+type LiteData struct {
+	Type string `json:"type"`
+	ID   string `json:"id"`
+}
+
 // Match defines the properties of a PUBG match
 type Match struct {
-	ID           string    `jsonapi:"primary,match"`
-	CreatedAt    time.Time `jsonapi:"attr,createdAt,iso8601"`
-	Duration     int       `jsonapi:"attr,duration"`
-	GameMode     string    `jsonapi:"attr,gameMode"`
-	PatchVersion string    `jsonapi:"attr,patchVersion"`
-	ShardID      string    `jsonapi:"attr,shardId"`
-	TitleID      string    `jsonapi:"attr,titleId"`
 }
 
 // ErrorMatchNotFound is used when trying to access a match that doesn't exist in the matches.Repository

players/player.go

@@ -5,27 +5,52 @@ import (
 	"errors"
 	"time"
 
+	"github.com/homeblest/pubg_stat_tracker/links"
 	"github.com/homeblest/pubg_stat_tracker/matches"
 )
 
+// Data defines the data properties of a player request from the PUBG API
+type Data struct {
+	Players []Player    `json:"data"`
+	Links   links.Link  `json:"links"`
+	Meta    interface{} `json:"meta"` // Not used by the PUBG API right now, but we must declare it to unmarshal the JSON
+}
+
+// attributes defines the attributes of a PUBG player.
+type attributes struct {
+	CreatedAt    time.Time   `json:"createdAt"`
+	Name         string      `json:"name"`
+	PatchVersion string      `json:"patchVersion"`
+	ShardID      string      `json:"shardId"`
+	Stats        interface{} `json:"stats"` // Not used by the PUBG API right now, stats are actually in the seasons.
+	TitleID      string      `json:"titleId"`
+	UpdatedAt    time.Time   `json:"updatedAt"`
+}
+
+type assets struct {
+	Data []interface{} `json:"data"`
+}
+
+type relationships struct {
+	Assets  assets       `json:"assets"`
+	Matches matches.Lite `json:"matches"`
+}
+
 // Player defines the properties of a PUBG character
 type Player struct {
-	ID           string           `jsonapi:"primary,player"`
-	Name         string           `jsonapi:"attr,name"`
-	ShardID      string           `jsonapi:"attr,shardId"`
-	CreatedAt    time.Time        `jsonapi:"attr,createdAt,iso8601"`
-	UpdatedAt    time.Time        `jsonapi:"attr,updatedAt,iso8601"`
-	PatchVersion string           `jsonapi:"attr,patchVersion"`
-	TitleID      string           `jsonapi:"attr,titleId"`
-	Matches      []*matches.Match `jsonapi:"relation,matches"`
+	Type          string        `json:"type"`
+	ID            string        `json:"id"`
+	Attributes    attributes    `json:"attributes"`
+	Relationships relationships `json:"relationships"`
+	Links         links.Link    `json:"links"`
 }
 
 // ErrorPlayerNotFound is used when trying to access a player that doesn't exist in the players.Repository
 var ErrorPlayerNotFound = errors.New("Player not found")
 
 // Repository provides access to the list of players
 type Repository interface {
-	Get(id string) (Player, error)
+	Get(id string) (*Player, error)
 	Add(Player) error
 }
 

requesting/const.go

@@ -0,0 +1,7 @@
+package requesting
+
+const (
+	pubgAPIBaseURL      string = "https://api.playbattlegrounds.com"
+	playersEndpoint     string = "/players"
+	pubgAPIBaseShardURL string = pubgAPIBaseURL + "/shards/%s%s"
+)

requesting/service.go

@@ -1,16 +1,15 @@
 package requesting
 
 import (
-	"compress/gzip"
+	"bytes"
+	"encoding/json"
 	"errors"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"net/http"
 	"net/url"
-	"reflect"
 
 	"github.com/homeblest/pubg_stat_tracker/players"
-	"github.com/slemgrim/jsonapi"
 )
 
 // Service takes care of requesting data from the PUBG API
@@ -29,41 +28,43 @@ func NewService(APIKey string) Service {
 	}
 }
 
-func (s *service) RequestPlayer(shard, name string) (*players.Player, error) {
-	parameters := url.Values{
-		"filter[playerNames]": {name},
+func (s *service) RequestPlayer(name, shard string) (*players.Player, error) {
+	players, err := s.RequestPlayers(name, shard)
+	if err != nil {
+		return nil, err
 	}
+	player := players[0]
+
+	fmt.Println("RequestPlayer:")
+	fmt.Println(player.Attributes.Name)
 
-	endpointURL := fmt.Sprintf("https://api.playbattlegrounds.com/shards/%s/players?%s", shard, parameters.Encode())
+	return &player, nil
+}
 
-	reader, err := httpRequest(endpointURL, s.APIKey)
+func (s *service) RequestPlayers(name, shard string) ([]players.Player, error) {
+	apiURL := fmt.Sprintf(pubgAPIBaseShardURL, string(shard), playersEndpoint)
 
+	query := url.Values{"filter[playerNames]": {name}}
+
+	body, err := createRequest(apiURL, s.APIKey, query)
 	if err != nil {
 		return nil, err
 	}
-	result, err := jsonapi.UnmarshalManyPayload(*reader, reflect.TypeOf(new(players.Player)))
 
+	playersData := &players.Data{}
+
+	err = json.NewDecoder(body).Decode(playersData)
 	if err != nil {
 		return nil, err
 	}
 
-	thePlayers := make([]*players.Player, len(result))
+	players := *playersData
 
-	for idx, elt := range result {
-		player, ok := elt.(*players.Player)
-		if !ok {
-			return nil, errors.New("Failed to convert players")
-		}
-		thePlayers[idx] = player
-	}
-	player := *thePlayers[0]
-	fmt.Println(player.Name)
-
-	return &player, nil
+	return players.Players, nil
 }
 
-// Request makes a request to the PUBG API
-func httpRequest(url, key string) (*io.Reader, error) {
+// createRequest makes a http GET request to the PUBG API
+func createRequest(url, key string, query url.Values) (*bytes.Buffer, error) {
 	// Create the request
 	req, err := http.NewRequest("GET", url, nil)
 
@@ -75,30 +76,36 @@ func httpRequest(url, key string) (*io.Reader, error) {
 	req.Header.Set("Authorization", key)
 	req.Header.Set("Accept", "application/vnd.api+json")
 
+	if query != nil {
+		req.URL.RawQuery = query.Encode()
+	}
+
 	// Send the request
-	client := &http.Client{}
-	response, err := client.Do(req)
+	res, err := http.DefaultClient.Do(req)
 
 	if err != nil {
 		return nil, err
 	}
 
-	if response.StatusCode != 200 {
-		response.Body.Close()
-		return nil, fmt.Errorf("HTTP request failed: %s", response.Status)
+	if res.StatusCode != http.StatusOK {
+		switch res.StatusCode {
+		case http.StatusUnauthorized:
+			return nil, errors.New("API key invalid or missing")
+		case http.StatusNotFound:
+			return nil, errors.New("The specified resource was not found")
+		case http.StatusUnsupportedMediaType:
+			return nil, errors.New("Content type incorrect or not specified")
+		case http.StatusTooManyRequests:
+			return nil, errors.New("Too many requests")
+		default:
+			return nil, errors.New(res.Status)
+		}
 	}
 
-	// Retrieve response body
-	var reader io.Reader
-	switch response.Header.Get("Content-Encoding") {
-	case "gzip":
-		reader, err = gzip.NewReader(response.Body)
-		if err != nil {
-			return nil, err
-		}
-	default:
-		reader = response.Body
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return nil, err
 	}
 
-	return &reader, nil
+	return bytes.NewBuffer(body), nil
 }

storage/memory.go

@@ -17,13 +17,13 @@ func (m *MemoryPlayerStorage) Add(player players.Player) error {
 }
 
 // Get retrieves the player from memory, if it exists
-func (m *MemoryPlayerStorage) Get(name string) (players.Player, error) {
+func (m *MemoryPlayerStorage) Get(name string) (*players.Player, error) {
 	var emptyPlayer players.Player
 
 	for i := range m.players {
-		if m.players[i].Name == name {
-			return m.players[i], nil
+		if m.players[i].Attributes.Name == name {
+			return &m.players[i], nil
 		}
 	}
-	return emptyPlayer, players.ErrorPlayerNotFound
+	return &emptyPlayer, players.ErrorPlayerNotFound
 }