package refactor

This commit is contained in:
Dawid Wysokiński 2020-06-07 17:04:57 +02:00
parent 64920bab73
commit 971c5e02b4
9 changed files with 471 additions and 417 deletions

View File

@ -3,11 +3,16 @@ package main
import (
"fmt"
"log"
"os"
"github.com/tribalwarshelp/golang-sdk/sdk"
"github.com/tribalwarshelp/shared/models"
)
func init() {
os.Setenv("TZ", "UTC")
}
func main() {
api := sdk.New("http://localhost:8080/graphql")
@ -141,7 +146,7 @@ func main() {
log.Fatal(err)
}
for _, ennoblement := range ennoblements {
fmt.Print("\n\n")
fmt.Print("\n\n", ennoblement.EnnobledAt.String(), "\n")
if ennoblement.NewOwner != nil {
log.Println(ennoblement.NewOwner.ID, ennoblement.NewOwner.Name)
if ennoblement.NewOwner.Tribe != nil {

76
sdk/ennoblements.go Normal file
View File

@ -0,0 +1,76 @@
package sdk
import (
"fmt"
"github.com/Kichiyaki/gqlgen-client/client"
"github.com/pkg/errors"
"github.com/tribalwarshelp/shared/models"
)
type Ennoblements struct {
sdk *SDK
}
type EnnoblementInclude struct {
NewOwner bool
NewOwnerInclude PlayerInclude
OldOwner bool
OldOwnerInclude PlayerInclude
Village bool
}
func (incl EnnoblementInclude) String() string {
i := ""
if incl.NewOwner {
i += fmt.Sprintf(`
newOwner {
%s
%s
}
`, playerFields, incl.NewOwnerInclude.String())
}
if incl.OldOwner {
i += fmt.Sprintf(`
oldOwner {
%s
%s
}
`, playerFields, incl.OldOwnerInclude.String())
}
if incl.Village {
i += fmt.Sprintf(`
village {
%s
}
`, villageFields)
}
return i
}
type ennoblementsResponse struct {
Ennoblements []*models.Ennoblement `json:"ennoblements" gqlgen:"ennoblements"`
}
func (en *Ennoblements) Browse(server string, include *EnnoblementInclude) ([]*models.Ennoblement, error) {
if server == "" {
return nil, ErrServerNameIsEmpty
}
if include == nil {
include = &EnnoblementInclude{}
}
resp := &ennoblementsResponse{}
query := fmt.Sprintf(`
query ennoblements($server: String!) {
ennoblements(server: $server) {
ennobledAt
%s
}
}
`, include.String())
err := en.sdk.client.Post(minifyString(query), &resp, client.Var("server", server))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Ennoblements, nil
}

7
sdk/helpers.go Normal file
View File

@ -0,0 +1,7 @@
package sdk
import "strings"
func minifyString(str string) string {
return strings.Join(strings.Fields(str), " ")
}

65
sdk/lang_versions.go Normal file
View File

@ -0,0 +1,65 @@
package sdk
import (
"github.com/Kichiyaki/gqlgen-client/client"
"github.com/pkg/errors"
"github.com/tribalwarshelp/shared/models"
)
type LangVersions struct {
sdk *SDK
}
func (lv *LangVersions) Read(tag models.LanguageTag) (*models.LangVersion, error) {
resp := struct {
LangVersion *models.LangVersion `json:"langVersion" gqlgen:"langVersion"`
}{}
query := `
query langVersion($tag: LanguageTag!) {
langVersion(tag: $tag) {
tag
name
host
timezone
}
}
`
err := lv.sdk.client.Post(minifyString(query), &resp, client.Var("tag", tag))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.LangVersion, nil
}
type LangVersionsList struct {
Items []*models.LangVersion `json:"items" gqlgen:"items"`
Total int `json:"total" gqlgen:"total"`
}
func (lv *LangVersions) Browse(filter *models.LangVersionFilter) (*LangVersionsList, error) {
if filter == nil {
filter = &models.LangVersionFilter{}
}
resp := struct {
LangVersions *LangVersionsList `json:"langVersions" gqlgen:"langVersions"`
}{}
query := `
query langVersions($filter: LangVersionFilter) {
langVersions(filter: $filter) {
items {
tag
name
host
timezone
}
total
}
}
`
err := lv.sdk.client.Post(minifyString(query), &resp, client.Var("filter", filter))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.LangVersions, nil
}

92
sdk/players.go Normal file
View File

@ -0,0 +1,92 @@
package sdk
import (
"fmt"
"github.com/Kichiyaki/gqlgen-client/client"
"github.com/pkg/errors"
"github.com/tribalwarshelp/shared/models"
)
type Players struct {
sdk *SDK
}
type PlayerInclude struct {
Tribe bool
}
func (incl PlayerInclude) String() string {
i := ""
if incl.Tribe {
i += fmt.Sprintf(`
tribe {
%s
}
`, tribeFields)
}
return i
}
func (ps *Players) Read(server string, id int, include *PlayerInclude) (*models.Player, error) {
if server == "" {
return nil, ErrServerNameIsEmpty
}
if include == nil {
include = &PlayerInclude{}
}
resp := struct {
Player *models.Player `json:"player" gqlgen:"player"`
}{}
query := fmt.Sprintf(`
query player($server: String!, $id: Int!) {
player(server: $server, id: $id) {
%s
%s
}
}
`, playerFields, include.String())
err := ps.sdk.client.Post(minifyString(query), &resp, client.Var("server", server), client.Var("id", id))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Player, nil
}
type PlayersList struct {
Items []*models.Player `json:"items" gqlgen:"items"`
Total int `json:"total" gqlgen:"total"`
}
func (ps *Players) Browse(server string, filter *models.PlayerFilter, include *PlayerInclude) (*PlayersList, error) {
if server == "" {
return nil, ErrServerNameIsEmpty
}
if filter == nil {
filter = &models.PlayerFilter{}
}
if include == nil {
include = &PlayerInclude{}
}
resp := struct {
Players *PlayersList `json:"players" gqlgen:"players"`
}{}
query := fmt.Sprintf(`
query players($server: String!, $filter: PlayerFilter) {
players(server: $server, filter: $filter) {
items {
%s
%s
}
total
}
}
`, playerFields, include.String())
err := ps.sdk.client.Post(minifyString(query), &resp, client.Var("filter", filter), client.Var("server", server))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Players, nil
}

View File

@ -4,12 +4,8 @@ import (
"fmt"
"io/ioutil"
"net/http"
"strings"
"github.com/Kichiyaki/gqlgen-client/client"
"github.com/pkg/errors"
"github.com/tribalwarshelp/shared/models"
)
var (
@ -59,7 +55,7 @@ var (
)
type SDK struct {
uri string
url string
client *client.Client
httpClient *http.Client
LangVersions *LangVersions
@ -70,9 +66,9 @@ type SDK struct {
Ennoblements *Ennoblements
}
func New(uri string) *SDK {
func New(url string) *SDK {
sdk := &SDK{
uri: uri,
url: url,
httpClient: &http.Client{},
}
sdk.client = client.New(http.HandlerFunc(sdk.handler))
@ -86,7 +82,7 @@ func New(uri string) *SDK {
}
func (sdk *SDK) handler(w http.ResponseWriter, r *http.Request) {
resp, err := sdk.httpClient.Post(sdk.uri, "application/json", r.Body)
resp, err := sdk.httpClient.Post(sdk.url, "application/json", r.Body)
if err != nil {
w.WriteHeader(400)
w.Write([]byte(err.Error()))
@ -102,411 +98,3 @@ func (sdk *SDK) handler(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(resp.StatusCode)
w.Write(body)
}
type LangVersions struct {
sdk *SDK
}
func (lv *LangVersions) Read(tag models.LanguageTag) (*models.LangVersion, error) {
resp := struct {
LangVersion *models.LangVersion `json:"langVersion" gqlgen:"langVersion"`
}{}
query := `
query langVersion($tag: LanguageTag!) {
langVersion(tag: $tag) {
tag
name
host
timezone
}
}
`
err := lv.sdk.client.Post(minify(query), &resp, client.Var("tag", tag))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.LangVersion, nil
}
type LangVersionsList struct {
Items []*models.LangVersion `json:"items" gqlgen:"items"`
Total int `json:"total" gqlgen:"total"`
}
func (lv *LangVersions) Browse(filter *models.LangVersionFilter) (*LangVersionsList, error) {
if filter == nil {
filter = &models.LangVersionFilter{}
}
resp := struct {
LangVersions *LangVersionsList `json:"langVersions" gqlgen:"langVersions"`
}{}
query := `
query langVersions($filter: LangVersionFilter) {
langVersions(filter: $filter) {
items {
tag
name
host
timezone
}
total
}
}
`
err := lv.sdk.client.Post(minify(query), &resp, client.Var("filter", filter))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.LangVersions, nil
}
type Servers struct {
sdk *SDK
}
func (ss *Servers) Read(key string) (*models.Server, error) {
resp := struct {
Server *models.Server `json:"server" gqlgen:"server"`
}{}
query := `
query server($key: String!) {
server(key: $key) {
id
key
status
langVersionTag
}
}
`
err := ss.sdk.client.Post(minify(query), &resp, client.Var("key", key))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Server, nil
}
type ServersList struct {
Items []*models.Server `json:"items" gqlgen:"items"`
Total int `json:"total" gqlgen:"total"`
}
func (ss *Servers) Browse(filter *models.ServerFilter) (*ServersList, error) {
if filter == nil {
filter = &models.ServerFilter{}
}
resp := struct {
Servers *ServersList `json:"servers" gqlgen:"servers"`
}{}
query := `
query servers($filter: ServerFilter) {
servers(filter: $filter) {
items {
id
key
status
langVersionTag
}
total
}
}
`
err := ss.sdk.client.Post(minify(query), &resp, client.Var("filter", filter))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Servers, nil
}
type Players struct {
sdk *SDK
}
type PlayerInclude struct {
Tribe bool
}
func (incl PlayerInclude) String() string {
i := ""
if incl.Tribe {
i += fmt.Sprintf(`
tribe {
%s
}
`, tribeFields)
}
return i
}
func (ps *Players) Read(server string, id int, include *PlayerInclude) (*models.Player, error) {
if server == "" {
return nil, ErrServerNameIsEmpty
}
if include == nil {
include = &PlayerInclude{}
}
resp := struct {
Player *models.Player `json:"player" gqlgen:"player"`
}{}
query := fmt.Sprintf(`
query player($server: String!, $id: Int!) {
player(server: $server, id: $id) {
%s
%s
}
}
`, playerFields, include.String())
err := ps.sdk.client.Post(minify(query), &resp, client.Var("server", server), client.Var("id", id))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Player, nil
}
type PlayersList struct {
Items []*models.Player `json:"items" gqlgen:"items"`
Total int `json:"total" gqlgen:"total"`
}
func (ps *Players) Browse(server string, filter *models.PlayerFilter, include *PlayerInclude) (*PlayersList, error) {
if server == "" {
return nil, ErrServerNameIsEmpty
}
if filter == nil {
filter = &models.PlayerFilter{}
}
if include == nil {
include = &PlayerInclude{}
}
resp := struct {
Players *PlayersList `json:"players" gqlgen:"players"`
}{}
query := fmt.Sprintf(`
query players($server: String!, $filter: PlayerFilter) {
players(server: $server, filter: $filter) {
items {
%s
%s
}
total
}
}
`, playerFields, include.String())
err := ps.sdk.client.Post(minify(query), &resp, client.Var("filter", filter), client.Var("server", server))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Players, nil
}
type Tribes struct {
sdk *SDK
}
func (ts *Tribes) Read(server string, id int) (*models.Tribe, error) {
resp := struct {
Tribe *models.Tribe `json:"tribe" gqlgen:"tribe"`
}{}
query := fmt.Sprintf(`
query tribe($server: String!, $id: Int!) {
tribe(server: $server, id: $id) {
%s
}
}
`, tribeFields)
err := ts.sdk.client.Post(minify(query), &resp, client.Var("server", server), client.Var("id", id))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Tribe, nil
}
type TribesList struct {
Items []*models.Tribe `json:"items" gqlgen:"items"`
Total int `json:"total" gqlgen:"total"`
}
func (ts *Tribes) Browse(server string, filter *models.TribeFilter) (*TribesList, error) {
if filter == nil {
filter = &models.TribeFilter{}
}
resp := struct {
Tribes *TribesList `json:"tribes" gqlgen:"tribes"`
}{}
query := fmt.Sprintf(`
query tribes($server: String!, $filter: TribeFilter) {
tribes(server: $server, filter: $filter) {
items {
%s
}
total
}
}
`, tribeFields)
err := ts.sdk.client.Post(minify(query), &resp, client.Var("server", server), client.Var("filter", filter))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Tribes, nil
}
type Villages struct {
sdk *SDK
}
type VillageInclude struct {
Player bool
PlayerInclude PlayerInclude
}
func (incl VillageInclude) String() string {
i := ""
if incl.Player {
i += fmt.Sprintf(`
player {
%s
%s
}
`, playerFields, incl.PlayerInclude.String())
}
return i
}
func (vs *Villages) Read(server string, id int, include *VillageInclude) (*models.Village, error) {
if server == "" {
return nil, ErrServerNameIsEmpty
}
if include == nil {
include = &VillageInclude{}
}
resp := struct {
Village *models.Village `json:"village" gqlgen:"village"`
}{}
query := fmt.Sprintf(`
query village($server: String!, $id: Int!) {
village(server: $server, id: $id) {
%s
%s
}
}
`, villageFields, include.String())
err := vs.sdk.client.Post(minify(query), &resp, client.Var("server", server), client.Var("id", id))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Village, nil
}
type VillagesList struct {
Items []*models.Village `json:"items" gqlgen:"items"`
Total int `json:"total" gqlgen:"total"`
}
func (vs *Villages) Browse(server string, filter *models.VillageFilter, include *VillageInclude) (*VillagesList, error) {
if server == "" {
return nil, ErrServerNameIsEmpty
}
if filter == nil {
filter = &models.VillageFilter{}
}
if include == nil {
include = &VillageInclude{}
}
resp := struct {
Villages *VillagesList
}{}
query := fmt.Sprintf(`
query villages($server: String!, $filter: VillageFilter) {
villages(server: $server, filter: $filter) {
items {
%s
%s
}
total
}
}
`, villageFields, include.String())
err := vs.sdk.client.Post(minify(query), &resp, client.Var("filter", filter), client.Var("server", server))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Villages, nil
}
type Ennoblements struct {
sdk *SDK
}
type EnnoblementInclude struct {
NewOwner bool
NewOwnerInclude PlayerInclude
OldOwner bool
OldOwnerInclude PlayerInclude
Village bool
}
func (incl EnnoblementInclude) String() string {
i := ""
if incl.NewOwner {
i += fmt.Sprintf(`
newOwner {
%s
%s
}
`, playerFields, incl.NewOwnerInclude.String())
}
if incl.OldOwner {
i += fmt.Sprintf(`
oldOwner {
%s
%s
}
`, playerFields, incl.OldOwnerInclude.String())
}
if incl.Village {
i += fmt.Sprintf(`
village {
%s
}
`, villageFields)
}
return i
}
type ennoblementsResponse struct {
Ennoblements []*models.Ennoblement `json:"ennoblements" gqlgen:"ennoblements"`
}
func (en *Ennoblements) Browse(server string, include *EnnoblementInclude) ([]*models.Ennoblement, error) {
if server == "" {
return nil, ErrServerNameIsEmpty
}
if include == nil {
include = &EnnoblementInclude{}
}
resp := &ennoblementsResponse{}
query := fmt.Sprintf(`
query ennoblements($server: String!) {
ennoblements(server: $server) {
ennobledAt
%s
}
}
`, include.String())
err := en.sdk.client.Post(minify(query), &resp, client.Var("server", server))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Ennoblements, nil
}
func minify(str string) string {
return strings.Join(strings.Fields(str), " ")
}

66
sdk/servers.go Normal file
View File

@ -0,0 +1,66 @@
package sdk
import (
"github.com/Kichiyaki/gqlgen-client/client"
"github.com/pkg/errors"
"github.com/tribalwarshelp/shared/models"
)
type Servers struct {
sdk *SDK
}
func (ss *Servers) Read(key string) (*models.Server, error) {
resp := struct {
Server *models.Server `json:"server" gqlgen:"server"`
}{}
query := `
query server($key: String!) {
server(key: $key) {
id
key
status
langVersionTag
}
}
`
err := ss.sdk.client.Post(minifyString(query), &resp, client.Var("key", key))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Server, nil
}
type ServersList struct {
Items []*models.Server `json:"items" gqlgen:"items"`
Total int `json:"total" gqlgen:"total"`
}
func (ss *Servers) Browse(filter *models.ServerFilter) (*ServersList, error) {
if filter == nil {
filter = &models.ServerFilter{}
}
resp := struct {
Servers *ServersList `json:"servers" gqlgen:"servers"`
}{}
query := `
query servers($filter: ServerFilter) {
servers(filter: $filter) {
items {
id
key
status
langVersionTag
}
total
}
}
`
err := ss.sdk.client.Post(minifyString(query), &resp, client.Var("filter", filter))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Servers, nil
}

61
sdk/tribes.go Normal file
View File

@ -0,0 +1,61 @@
package sdk
import (
"fmt"
"github.com/Kichiyaki/gqlgen-client/client"
"github.com/pkg/errors"
"github.com/tribalwarshelp/shared/models"
)
type Tribes struct {
sdk *SDK
}
func (ts *Tribes) Read(server string, id int) (*models.Tribe, error) {
resp := struct {
Tribe *models.Tribe `json:"tribe" gqlgen:"tribe"`
}{}
query := fmt.Sprintf(`
query tribe($server: String!, $id: Int!) {
tribe(server: $server, id: $id) {
%s
}
}
`, tribeFields)
err := ts.sdk.client.Post(minifyString(query), &resp, client.Var("server", server), client.Var("id", id))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Tribe, nil
}
type TribesList struct {
Items []*models.Tribe `json:"items" gqlgen:"items"`
Total int `json:"total" gqlgen:"total"`
}
func (ts *Tribes) Browse(server string, filter *models.TribeFilter) (*TribesList, error) {
if filter == nil {
filter = &models.TribeFilter{}
}
resp := struct {
Tribes *TribesList `json:"tribes" gqlgen:"tribes"`
}{}
query := fmt.Sprintf(`
query tribes($server: String!, $filter: TribeFilter) {
tribes(server: $server, filter: $filter) {
items {
%s
}
total
}
}
`, tribeFields)
err := ts.sdk.client.Post(minifyString(query), &resp, client.Var("server", server), client.Var("filter", filter))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Tribes, nil
}

94
sdk/villages.go Normal file
View File

@ -0,0 +1,94 @@
package sdk
import (
"fmt"
"github.com/Kichiyaki/gqlgen-client/client"
"github.com/pkg/errors"
"github.com/tribalwarshelp/shared/models"
)
type Villages struct {
sdk *SDK
}
type VillageInclude struct {
Player bool
PlayerInclude PlayerInclude
}
func (incl VillageInclude) String() string {
i := ""
if incl.Player {
i += fmt.Sprintf(`
player {
%s
%s
}
`, playerFields, incl.PlayerInclude.String())
}
return i
}
func (vs *Villages) Read(server string, id int, include *VillageInclude) (*models.Village, error) {
if server == "" {
return nil, ErrServerNameIsEmpty
}
if include == nil {
include = &VillageInclude{}
}
resp := struct {
Village *models.Village `json:"village" gqlgen:"village"`
}{}
query := fmt.Sprintf(`
query village($server: String!, $id: Int!) {
village(server: $server, id: $id) {
%s
%s
}
}
`, villageFields, include.String())
err := vs.sdk.client.Post(minifyString(query), &resp, client.Var("server", server), client.Var("id", id))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Village, nil
}
type VillagesList struct {
Items []*models.Village `json:"items" gqlgen:"items"`
Total int `json:"total" gqlgen:"total"`
}
func (vs *Villages) Browse(server string, filter *models.VillageFilter, include *VillageInclude) (*VillagesList, error) {
if server == "" {
return nil, ErrServerNameIsEmpty
}
if filter == nil {
filter = &models.VillageFilter{}
}
if include == nil {
include = &VillageInclude{}
}
resp := struct {
Villages *VillagesList
}{}
query := fmt.Sprintf(`
query villages($server: String!, $filter: VillageFilter) {
villages(server: $server, filter: $filter) {
items {
%s
%s
}
total
}
}
`, villageFields, include.String())
err := vs.sdk.client.Post(minifyString(query), &resp, client.Var("filter", filter), client.Var("server", server))
if err != nil {
return nil, errors.Wrap(err, "twhelp sdk")
}
return resp.Villages, nil
}