809 lines
18 KiB
Go
809 lines
18 KiB
Go
package tw
|
|
|
|
import (
|
|
"cmp"
|
|
"context"
|
|
"encoding/csv"
|
|
"encoding/xml"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"slices"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/elliotchance/phpserialize"
|
|
)
|
|
|
|
const (
|
|
endpointPlayers = "/map/player.txt"
|
|
endpointTribes = "/map/ally.txt"
|
|
endpointVillages = "/map/village.txt"
|
|
endpointPlayersODA = "/map/kill_att.txt"
|
|
endpointPlayersODD = "/map/kill_def.txt"
|
|
endpointPlayersODS = "/map/kill_sup.txt"
|
|
endpointPlayersOD = "/map/kill_all.txt"
|
|
endpointTribesODA = "/map/kill_att_tribe.txt"
|
|
endpointTribesODD = "/map/kill_def_tribe.txt"
|
|
endpointTribesOD = "/map/kill_all_tribe.txt"
|
|
endpointEnnoblements = "/map/conquer_extended.txt"
|
|
endpointInterface = "/interface.php"
|
|
endpointGetServers = "/backend/get_servers.php"
|
|
endpointGame = "/game.php"
|
|
)
|
|
|
|
const (
|
|
queryConfig = "func=get_config"
|
|
queryUnitInfo = "func=get_unit_info"
|
|
queryBuildingInfo = "func=get_building_info"
|
|
queryInterfaceEnnoblements = "func=get_conquer_extended&since=%d"
|
|
queryPlayerProfile = "screen=info_player&id=%d"
|
|
queryTribeProfile = "screen=info_ally&id=%d"
|
|
queryVillageProfile = "screen=info_village&id=%d"
|
|
)
|
|
|
|
type Client struct {
|
|
client *http.Client
|
|
userAgent string
|
|
ennoblementsUseInterfaceFunc func(since time.Time) bool
|
|
}
|
|
|
|
func NewClient(opts ...ClientOption) *Client {
|
|
cfg := newClientConfig(opts...)
|
|
return &Client{
|
|
client: cfg.client,
|
|
userAgent: cfg.userAgent,
|
|
ennoblementsUseInterfaceFunc: cfg.ennoblementsUseInterfaceFunc,
|
|
}
|
|
}
|
|
|
|
var ErrBaseURLCantBeNil = errors.New("baseURL can't be nil")
|
|
|
|
var (
|
|
ErrInvalidServerKey = errors.New("invalid server key")
|
|
ErrInvalidServerURL = errors.New("invalid server URL")
|
|
)
|
|
|
|
func (c *Client) GetOpenServers(ctx context.Context, baseURL *url.URL) ([]Server, error) {
|
|
if baseURL == nil {
|
|
return nil, ErrBaseURLCantBeNil
|
|
}
|
|
|
|
resp, err := c.get(ctx, buildURL(baseURL, endpointGetServers))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() {
|
|
_ = resp.Body.Close()
|
|
}()
|
|
|
|
return serverParser{r: resp.Body}.parse()
|
|
}
|
|
|
|
func (c *Client) GetServerConfig(ctx context.Context, baseURL *url.URL) (ServerConfig, error) {
|
|
if baseURL == nil {
|
|
return ServerConfig{}, ErrBaseURLCantBeNil
|
|
}
|
|
|
|
var cfg ServerConfig
|
|
|
|
if err := c.getXML(ctx, buildURLWithQuery(baseURL, endpointInterface, queryConfig), &cfg); err != nil {
|
|
return ServerConfig{}, err
|
|
}
|
|
|
|
return cfg, nil
|
|
}
|
|
|
|
func (c *Client) GetBuildingInfo(ctx context.Context, baseURL *url.URL) (BuildingInfo, error) {
|
|
if baseURL == nil {
|
|
return BuildingInfo{}, ErrBaseURLCantBeNil
|
|
}
|
|
|
|
var info BuildingInfo
|
|
|
|
if err := c.getXML(ctx, buildURLWithQuery(baseURL, endpointInterface, queryBuildingInfo), &info); err != nil {
|
|
return BuildingInfo{}, err
|
|
}
|
|
|
|
return info, nil
|
|
}
|
|
|
|
func (c *Client) GetUnitInfo(ctx context.Context, baseURL *url.URL) (UnitInfo, error) {
|
|
if baseURL == nil {
|
|
return UnitInfo{}, ErrBaseURLCantBeNil
|
|
}
|
|
|
|
var info UnitInfo
|
|
|
|
if err := c.getXML(ctx, buildURLWithQuery(baseURL, endpointInterface, queryUnitInfo), &info); err != nil {
|
|
return UnitInfo{}, err
|
|
}
|
|
|
|
return info, nil
|
|
}
|
|
|
|
func (c *Client) GetTribes(ctx context.Context, baseURL *url.URL) ([]Tribe, error) {
|
|
if baseURL == nil {
|
|
return nil, ErrBaseURLCantBeNil
|
|
}
|
|
|
|
od, err := c.getOD(ctx, baseURL, true)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
resp, err := c.get(ctx, buildURL(baseURL, endpointTribes))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() {
|
|
_ = resp.Body.Close()
|
|
}()
|
|
|
|
return tribeCSVParser{
|
|
r: resp.Body,
|
|
baseURL: baseURL,
|
|
od: od,
|
|
}.parse()
|
|
}
|
|
|
|
func (c *Client) GetPlayers(ctx context.Context, baseURL *url.URL) ([]Player, error) {
|
|
if baseURL == nil {
|
|
return nil, ErrBaseURLCantBeNil
|
|
}
|
|
|
|
od, err := c.getOD(ctx, baseURL, false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
resp, err := c.get(ctx, buildURL(baseURL, endpointPlayers))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() {
|
|
_ = resp.Body.Close()
|
|
}()
|
|
|
|
return playerCSVParser{
|
|
r: resp.Body,
|
|
baseURL: baseURL,
|
|
od: od,
|
|
}.parse()
|
|
}
|
|
|
|
func (c *Client) getOD(ctx context.Context, baseURL *url.URL, tribe bool) (map[int]OpponentsDefeated, error) {
|
|
m := make(map[int]OpponentsDefeated)
|
|
urls := buildODURLs(baseURL, tribe)
|
|
|
|
for _, u := range urls {
|
|
if u == nil {
|
|
continue
|
|
}
|
|
|
|
records, err := c.getSingleODFile(ctx, u)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, rec := range records {
|
|
od := m[rec.ID]
|
|
|
|
switch u {
|
|
case urls[0]:
|
|
od.RankTotal = rec.Rank
|
|
od.ScoreTotal = rec.Score
|
|
case urls[1]:
|
|
od.RankAtt = rec.Rank
|
|
od.ScoreAtt = rec.Score
|
|
case urls[2]:
|
|
od.RankDef = rec.Rank
|
|
od.ScoreDef = rec.Score
|
|
case urls[3]:
|
|
od.RankSup = rec.Rank
|
|
od.ScoreSup = rec.Score
|
|
}
|
|
|
|
m[rec.ID] = od
|
|
}
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
func (c *Client) getSingleODFile(ctx context.Context, u *url.URL) ([]odRecord, error) {
|
|
resp, err := c.get(ctx, u)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() {
|
|
_ = resp.Body.Close()
|
|
}()
|
|
|
|
return odCSVParser{
|
|
r: resp.Body,
|
|
}.parse()
|
|
}
|
|
|
|
func (c *Client) GetVillages(ctx context.Context, baseURL *url.URL) ([]Village, error) {
|
|
if baseURL == nil {
|
|
return nil, ErrBaseURLCantBeNil
|
|
}
|
|
|
|
resp, err := c.get(ctx, buildURL(baseURL, endpointVillages))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() {
|
|
_ = resp.Body.Close()
|
|
}()
|
|
|
|
return villageCSVParser{
|
|
r: resp.Body,
|
|
baseURL: baseURL,
|
|
}.parse()
|
|
}
|
|
|
|
func (c *Client) GetEnnoblements(ctx context.Context, baseURL *url.URL, since time.Time) ([]Ennoblement, error) {
|
|
if baseURL == nil {
|
|
return nil, ErrBaseURLCantBeNil
|
|
}
|
|
|
|
u := buildURL(baseURL, endpointEnnoblements)
|
|
if c.ennoblementsUseInterfaceFunc(since) {
|
|
u = buildURLWithQuery(baseURL, endpointInterface, fmt.Sprintf(queryInterfaceEnnoblements, since.Unix()))
|
|
}
|
|
|
|
resp, err := c.get(ctx, u)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() {
|
|
_ = resp.Body.Close()
|
|
}()
|
|
|
|
return ennoblementCSVParser{
|
|
r: resp.Body,
|
|
since: since,
|
|
}.parse()
|
|
}
|
|
|
|
func (c *Client) getXML(ctx context.Context, u *url.URL, v any) error {
|
|
resp, err := c.get(ctx, u)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() {
|
|
_ = resp.Body.Close()
|
|
}()
|
|
|
|
if err = xml.NewDecoder(resp.Body).Decode(v); err != nil {
|
|
return fmt.Errorf("%s: %w", u, err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (c *Client) get(ctx context.Context, u *url.URL) (*http.Response, error) {
|
|
urlStr := u.String()
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, urlStr, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// headers
|
|
req.Header.Set("User-Agent", c.userAgent)
|
|
|
|
resp, err := c.client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%s: %w", urlStr, err)
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
_, _ = io.Copy(io.Discard, resp.Body)
|
|
_ = resp.Body.Close()
|
|
return nil, fmt.Errorf("%s: got non-ok HTTP status: %d", urlStr, resp.StatusCode)
|
|
}
|
|
|
|
return resp, nil
|
|
}
|
|
|
|
type serverParser struct {
|
|
r io.Reader
|
|
}
|
|
|
|
func (p serverParser) parse() ([]Server, error) {
|
|
b, err := io.ReadAll(p.r)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("couldn't read data: %w", err)
|
|
}
|
|
|
|
m, err := phpserialize.UnmarshalAssociativeArray(b)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("couldn't unmarshal response body: %w", err)
|
|
}
|
|
|
|
servers := make([]Server, 0, len(m))
|
|
|
|
for key, val := range m {
|
|
keyStr, ok := key.(string)
|
|
if !ok || keyStr == "" {
|
|
return nil, fmt.Errorf("parsing '%v': %w", key, ErrInvalidServerKey)
|
|
}
|
|
|
|
urlStr, ok := val.(string)
|
|
if !ok || urlStr == "" {
|
|
return nil, fmt.Errorf("parsing '%v': %w", val, ErrInvalidServerURL)
|
|
}
|
|
|
|
serverURL, parseErr := url.ParseRequestURI(urlStr)
|
|
if parseErr != nil {
|
|
return nil, fmt.Errorf("parsing '%v': %w", val, parseErr)
|
|
}
|
|
|
|
servers = append(servers, Server{
|
|
Key: keyStr,
|
|
URL: serverURL,
|
|
})
|
|
}
|
|
|
|
return servers, nil
|
|
}
|
|
|
|
type tribeCSVParser struct {
|
|
r io.Reader
|
|
baseURL *url.URL
|
|
od map[int]OpponentsDefeated
|
|
}
|
|
|
|
const fieldsPerRecordTribe = 8
|
|
|
|
func (p tribeCSVParser) parse() ([]Tribe, error) {
|
|
csvR := newCSVReader(p.r, fieldsPerRecordTribe)
|
|
|
|
var tribes []Tribe
|
|
for {
|
|
rec, err := csvR.Read()
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
tribe, err := p.parseRecord(rec)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
tribes = append(tribes, tribe)
|
|
}
|
|
|
|
slices.SortFunc(tribes, func(a, b Tribe) int {
|
|
return cmp.Compare(a.ID, b.ID)
|
|
})
|
|
|
|
return tribes, nil
|
|
}
|
|
|
|
func (p tribeCSVParser) parseRecord(record []string) (Tribe, error) {
|
|
var err error
|
|
var tribe Tribe
|
|
|
|
// $id, $name, $tag, $members, $villages, $points, $all_points, $rank
|
|
|
|
tribe.ID, err = strconv.Atoi(record[0])
|
|
if err != nil {
|
|
return Tribe{}, ParseError{Err: err, Str: record[0], Field: "Tribe.ID"}
|
|
}
|
|
|
|
tribe.Name, err = url.QueryUnescape(record[1])
|
|
if err != nil {
|
|
return Tribe{}, ParseError{Err: err, Str: record[1], Field: "Tribe.Name"}
|
|
}
|
|
|
|
tribe.Tag, err = url.QueryUnescape(record[2])
|
|
if err != nil {
|
|
return Tribe{}, ParseError{Err: err, Str: record[2], Field: "Tribe.Tag"}
|
|
}
|
|
|
|
tribe.NumMembers, err = strconv.Atoi(record[3])
|
|
if err != nil {
|
|
return Tribe{}, ParseError{Err: err, Str: record[3], Field: "Tribe.NumMembers"}
|
|
}
|
|
|
|
tribe.NumVillages, err = strconv.Atoi(record[4])
|
|
if err != nil {
|
|
return Tribe{}, ParseError{Err: err, Str: record[4], Field: "Tribe.NumVillages"}
|
|
}
|
|
|
|
tribe.Points, err = strconv.Atoi(record[5])
|
|
if err != nil {
|
|
return Tribe{}, ParseError{Err: err, Str: record[5], Field: "Tribe.Points"}
|
|
}
|
|
|
|
tribe.AllPoints, err = strconv.Atoi(record[6])
|
|
if err != nil {
|
|
return Tribe{}, ParseError{Err: err, Str: record[6], Field: "Tribe.AllPoints"}
|
|
}
|
|
|
|
tribe.Rank, err = strconv.Atoi(record[7])
|
|
if err != nil {
|
|
return Tribe{}, ParseError{Err: err, Str: record[7], Field: "Tribe.Rank"}
|
|
}
|
|
|
|
tribe.OpponentsDefeated = p.od[tribe.ID]
|
|
|
|
tribe.ProfileURL = buildURLWithQuery(p.baseURL, endpointGame, fmt.Sprintf(queryTribeProfile, tribe.ID))
|
|
|
|
return tribe, nil
|
|
}
|
|
|
|
type playerCSVParser struct {
|
|
r io.Reader
|
|
od map[int]OpponentsDefeated
|
|
baseURL *url.URL
|
|
}
|
|
|
|
const fieldsPerRecordPlayer = 6
|
|
|
|
func (p playerCSVParser) parse() ([]Player, error) {
|
|
csvR := newCSVReader(p.r, fieldsPerRecordPlayer)
|
|
|
|
var players []Player
|
|
for {
|
|
rec, err := csvR.Read()
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
player, err := p.parseRecord(rec)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
players = append(players, player)
|
|
}
|
|
|
|
slices.SortFunc(players, func(a, b Player) int {
|
|
return cmp.Compare(a.ID, b.ID)
|
|
})
|
|
|
|
return players, nil
|
|
}
|
|
|
|
func (p playerCSVParser) parseRecord(record []string) (Player, error) {
|
|
var err error
|
|
var player Player
|
|
|
|
// $id, $name, $ally, $villages, $points, $rank
|
|
|
|
player.ID, err = strconv.Atoi(record[0])
|
|
if err != nil {
|
|
return Player{}, ParseError{Err: err, Str: record[0], Field: "Player.ID"}
|
|
}
|
|
|
|
player.Name, err = url.QueryUnescape(record[1])
|
|
if err != nil {
|
|
return Player{}, ParseError{Err: err, Str: record[1], Field: "Player.Name"}
|
|
}
|
|
|
|
player.TribeID, err = strconv.Atoi(record[2])
|
|
if err != nil {
|
|
return Player{}, ParseError{Err: err, Str: record[2], Field: "Player.TribeID"}
|
|
}
|
|
|
|
player.NumVillages, err = strconv.Atoi(record[3])
|
|
if err != nil {
|
|
return Player{}, ParseError{Err: err, Str: record[3], Field: "Player.NumVillages"}
|
|
}
|
|
|
|
player.Points, err = strconv.Atoi(record[4])
|
|
if err != nil {
|
|
return Player{}, ParseError{Err: err, Str: record[4], Field: "Player.Points"}
|
|
}
|
|
|
|
player.Rank, err = strconv.Atoi(record[5])
|
|
if err != nil {
|
|
return Player{}, ParseError{Err: err, Str: record[5], Field: "Player.Rank"}
|
|
}
|
|
|
|
player.OpponentsDefeated = p.od[player.ID]
|
|
|
|
player.ProfileURL = buildURLWithQuery(p.baseURL, endpointGame, fmt.Sprintf(queryPlayerProfile, player.ID))
|
|
|
|
return player, nil
|
|
}
|
|
|
|
type villageCSVParser struct {
|
|
r io.Reader
|
|
baseURL *url.URL
|
|
}
|
|
|
|
const fieldsPerRecordVillage = 7
|
|
|
|
func (p villageCSVParser) parse() ([]Village, error) {
|
|
csvR := newCSVReader(p.r, fieldsPerRecordVillage)
|
|
|
|
var villages []Village
|
|
for {
|
|
rec, err := csvR.Read()
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
village, err := p.parseRecord(rec)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
villages = append(villages, village)
|
|
}
|
|
|
|
slices.SortFunc(villages, func(a, b Village) int {
|
|
return cmp.Compare(a.ID, b.ID)
|
|
})
|
|
|
|
return villages, nil
|
|
}
|
|
|
|
func (p villageCSVParser) parseRecord(record []string) (Village, error) {
|
|
var err error
|
|
var village Village
|
|
|
|
// $id, $name, $x, $y, $player, $points, $bonus_id
|
|
|
|
village.ID, err = strconv.Atoi(record[0])
|
|
if err != nil {
|
|
return Village{}, ParseError{Err: err, Str: record[0], Field: "Village.ID"}
|
|
}
|
|
|
|
village.Name, err = url.QueryUnescape(record[1])
|
|
if err != nil {
|
|
return Village{}, ParseError{Err: err, Str: record[1], Field: "Village.Name"}
|
|
}
|
|
|
|
village.X, err = strconv.Atoi(record[2])
|
|
if err != nil {
|
|
return Village{}, ParseError{Err: err, Str: record[2], Field: "Village.X"}
|
|
}
|
|
|
|
village.Y, err = strconv.Atoi(record[3])
|
|
if err != nil {
|
|
return Village{}, ParseError{Err: err, Str: record[3], Field: "Village.Y"}
|
|
}
|
|
|
|
village.PlayerID, err = strconv.Atoi(record[4])
|
|
if err != nil {
|
|
return Village{}, ParseError{Err: err, Str: record[4], Field: "Village.PlayerID"}
|
|
}
|
|
|
|
village.Points, err = strconv.Atoi(record[5])
|
|
if err != nil {
|
|
return Village{}, ParseError{Err: err, Str: record[5], Field: "Village.Points"}
|
|
}
|
|
|
|
village.Bonus, err = strconv.Atoi(record[6])
|
|
if err != nil {
|
|
return Village{}, ParseError{Err: err, Str: record[6], Field: "Village.Bonus"}
|
|
}
|
|
|
|
village.Continent = p.buildContinent(record, village.X, village.Y)
|
|
|
|
village.ProfileURL = buildURLWithQuery(p.baseURL, endpointGame, fmt.Sprintf(queryVillageProfile, village.ID))
|
|
|
|
return village, nil
|
|
}
|
|
|
|
func (p villageCSVParser) buildContinent(record []string, x, y int) string {
|
|
continent := "K"
|
|
|
|
switch {
|
|
case x < 100 && y < 100:
|
|
continent += "0"
|
|
case x > 100 && y < 100:
|
|
continent += string(record[2][0])
|
|
case x < 100 && y > 100:
|
|
continent += string(record[3][0]) + "0"
|
|
default:
|
|
continent += string(record[3][0]) + string(record[2][0])
|
|
}
|
|
|
|
return continent
|
|
}
|
|
|
|
type odCSVParser struct {
|
|
r io.Reader
|
|
}
|
|
|
|
type odRecord struct {
|
|
ID int
|
|
Rank int
|
|
Score int
|
|
}
|
|
|
|
const fieldsPerRecordOD = 3
|
|
|
|
func (p odCSVParser) parse() ([]odRecord, error) {
|
|
csvR := newCSVReader(p.r, fieldsPerRecordOD)
|
|
|
|
var odRecords []odRecord
|
|
for {
|
|
rec, err := csvR.Read()
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
od, err := p.parseRecord(rec)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
odRecords = append(odRecords, od)
|
|
}
|
|
|
|
return odRecords, nil
|
|
}
|
|
|
|
func (p odCSVParser) parseRecord(record []string) (odRecord, error) {
|
|
var err error
|
|
var rec odRecord
|
|
|
|
// $rank, $id, $score
|
|
|
|
rec.Rank, err = strconv.Atoi(record[0])
|
|
if err != nil {
|
|
return odRecord{}, ParseError{Err: err, Str: record[0], Field: "odRecord.Rank"}
|
|
}
|
|
|
|
rec.ID, err = strconv.Atoi(record[1])
|
|
if err != nil {
|
|
return odRecord{}, ParseError{Err: err, Str: record[1], Field: "odRecord.ID"}
|
|
}
|
|
|
|
rec.Score, err = strconv.Atoi(record[2])
|
|
if err != nil {
|
|
return odRecord{}, ParseError{Err: err, Str: record[2], Field: "odRecord.Score"}
|
|
}
|
|
|
|
return rec, nil
|
|
}
|
|
|
|
type ennoblementCSVParser struct {
|
|
r io.Reader
|
|
since time.Time
|
|
}
|
|
|
|
const fieldsPerRecordEnnoblement = 7
|
|
|
|
func (p ennoblementCSVParser) parse() ([]Ennoblement, error) {
|
|
csvR := newCSVReader(p.r, fieldsPerRecordEnnoblement)
|
|
|
|
var ennoblements []Ennoblement
|
|
for {
|
|
rec, err := csvR.Read()
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ennoblement, err := p.parseRecord(rec)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if ennoblement.CreatedAt.Before(p.since) {
|
|
continue
|
|
}
|
|
|
|
ennoblements = append(ennoblements, ennoblement)
|
|
}
|
|
|
|
slices.SortFunc(ennoblements, func(a, b Ennoblement) int {
|
|
return a.CreatedAt.Compare(b.CreatedAt)
|
|
})
|
|
|
|
return ennoblements, nil
|
|
}
|
|
|
|
func (p ennoblementCSVParser) parseRecord(record []string) (Ennoblement, error) {
|
|
var err error
|
|
var ennoblement Ennoblement
|
|
|
|
// $village_id, $unix_timestamp, $new_owner, $old_owner, $old_tribe_id, $new_tribe_id, $points
|
|
|
|
ennoblement.VillageID, err = strconv.Atoi(record[0])
|
|
if err != nil {
|
|
return Ennoblement{}, ParseError{Err: err, Str: record[0], Field: "Ennoblement.VillageID"}
|
|
}
|
|
|
|
ennoblement.CreatedAt, err = p.parseTimestamp(record[1])
|
|
if err != nil {
|
|
return Ennoblement{}, ParseError{Err: err, Str: record[1], Field: "Ennoblement.CreatedAt"}
|
|
}
|
|
|
|
ennoblement.NewOwnerID, err = strconv.Atoi(record[2])
|
|
if err != nil {
|
|
return Ennoblement{}, ParseError{Err: err, Str: record[2], Field: "Ennoblement.NewOwnerID"}
|
|
}
|
|
|
|
ennoblement.OldOwnerID, err = strconv.Atoi(record[3])
|
|
if err != nil {
|
|
return Ennoblement{}, ParseError{Err: err, Str: record[3], Field: "Ennoblement.OldOwnerID"}
|
|
}
|
|
|
|
ennoblement.OldTribeID, err = strconv.Atoi(record[4])
|
|
if err != nil {
|
|
return Ennoblement{}, ParseError{Err: err, Str: record[4], Field: "Ennoblement.OldTribeID"}
|
|
}
|
|
|
|
ennoblement.NewTribeID, err = strconv.Atoi(record[5])
|
|
if err != nil {
|
|
return Ennoblement{}, ParseError{Err: err, Str: record[5], Field: "Ennoblement.NewTribeID"}
|
|
}
|
|
|
|
ennoblement.Points, err = strconv.Atoi(record[6])
|
|
if err != nil {
|
|
return Ennoblement{}, ParseError{Err: err, Str: record[6], Field: "Ennoblement.Points"}
|
|
}
|
|
|
|
return ennoblement, nil
|
|
}
|
|
|
|
func (p ennoblementCSVParser) parseTimestamp(s string) (time.Time, error) {
|
|
timestamp, err := strconv.ParseInt(s, 10, 64)
|
|
if err != nil {
|
|
return time.Time{}, err
|
|
}
|
|
return time.Unix(timestamp, 0), nil
|
|
}
|
|
|
|
func newCSVReader(r io.Reader, fieldsPerRecord int) *csv.Reader {
|
|
csvR := csv.NewReader(r)
|
|
csvR.Comma = ','
|
|
csvR.FieldsPerRecord = fieldsPerRecord
|
|
csvR.ReuseRecord = true
|
|
return csvR
|
|
}
|
|
|
|
//nolint:revive
|
|
func buildODURLs(base *url.URL, tribe bool) [4]*url.URL {
|
|
// there is no endpoint to get opponents defeated as supporter for tribes :(
|
|
if tribe {
|
|
return [4]*url.URL{
|
|
buildURL(base, endpointTribesOD),
|
|
buildURL(base, endpointTribesODA),
|
|
buildURL(base, endpointTribesODD),
|
|
nil,
|
|
}
|
|
}
|
|
return [4]*url.URL{
|
|
buildURL(base, endpointPlayersOD),
|
|
buildURL(base, endpointPlayersODA),
|
|
buildURL(base, endpointPlayersODD),
|
|
buildURL(base, endpointPlayersODS),
|
|
}
|
|
}
|
|
|
|
func buildURL(base *url.URL, path string) *url.URL {
|
|
return buildURLWithQuery(base, path, "")
|
|
}
|
|
|
|
func buildURLWithQuery(base *url.URL, path, query string) *url.URL {
|
|
newURL := *base
|
|
newURL.Path = path
|
|
newURL.RawQuery = query
|
|
return &newURL
|
|
}
|