twhelp
/
api
Archived
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add tribechange usecase, repository, resolver

This commit is contained in:
Dawid Wysokiński 2020-06-24 15:25:31 +02:00
parent 87562c3f4c
commit ebc2b95002
14 changed files with 862 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
go.mod
View File

@ -14,7 +14,7 @@ require (
github.com/pkg/errors v0.9.1
github.com/segmentio/encoding v0.1.14 // indirect
github.com/tribalwarshelp/map-generator v0.0.0-20200623143352-cc037d744be2
github.com/tribalwarshelp/shared v0.0.0-20200623144748-aa834a01dce6
github.com/tribalwarshelp/shared v0.0.0-20200624131453-e04f1de1bf5c
github.com/vektah/gqlparser/v2 v2.0.1
golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1 // indirect
gopkg.in/yaml.v2 v2.3.0 // indirect

2
go.sum
View File

@ -177,6 +177,8 @@ github.com/tribalwarshelp/shared v0.0.0-20200622084436-3a768c8bf574 h1:y2EoH6zRK
github.com/tribalwarshelp/shared v0.0.0-20200622084436-3a768c8bf574/go.mod h1:tf+2yTHasV6jAF3V2deZ9slNoCyBzC0fMdTjI7clf6Y=
github.com/tribalwarshelp/shared v0.0.0-20200623144748-aa834a01dce6 h1:WZ1oxHysFtiPjHa2ADUqiGrzwcN3j0YpiVg/V2e/74o=
github.com/tribalwarshelp/shared v0.0.0-20200623144748-aa834a01dce6/go.mod h1:tf+2yTHasV6jAF3V2deZ9slNoCyBzC0fMdTjI7clf6Y=
github.com/tribalwarshelp/shared v0.0.0-20200624131453-e04f1de1bf5c h1:sPu2tYRqZYAFwhJtZ4cDWLwanauQ4+4zlGEgdQNrVn4=
github.com/tribalwarshelp/shared v0.0.0-20200624131453-e04f1de1bf5c/go.mod h1:tf+2yTHasV6jAF3V2deZ9slNoCyBzC0fMdTjI7clf6Y=
github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs=

645
graphql/generated/generated.go
View File

@ -42,6 +42,7 @@ type ResolverRoot interface {
PlayerHistoryRecord() PlayerHistoryRecordResolver
Query() QueryResolver
Server() ServerResolver
TribeChangeRecord() TribeChangeRecordResolver
TribeHistoryRecord() TribeHistoryRecordResolver
Village() VillageResolver
}
@ -178,6 +179,7 @@ type ComplexityRoot struct {
ServerStats func(childComplexity int, server string, filter *models.ServerStatsFilter) int
Servers func(childComplexity int, filter *models.ServerFilter) int
Tribe func(childComplexity int, server string, id int) int
TribeChanges func(childComplexity int, server string, filter *models.TribeChangeFilter) int
TribeHistory func(childComplexity int, server string, filter *models.TribeHistoryFilter) int
Tribes func(childComplexity int, server string, filter *models.TribeFilter) int
Village func(childComplexity int, server string, id int) int
@ -393,6 +395,18 @@ type ComplexityRoot struct {
TotalVillages func(childComplexity int) int
}
TribeChangeRecord struct {
CreatedAt func(childComplexity int) int
NewTribe func(childComplexity int) int
OldTribe func(childComplexity int) int
Player func(childComplexity int) int
}
TribeChanges struct {
Items func(childComplexity int) int
Total func(childComplexity int) int
}
TribeHistory struct {
Items func(childComplexity int) int
Total func(childComplexity int) int
@ -497,6 +511,7 @@ type QueryResolver interface {
ServerStats(ctx context.Context, server string, filter *models.ServerStatsFilter) (*ServerStats, error)
Tribes(ctx context.Context, server string, filter *models.TribeFilter) (*TribesList, error)
Tribe(ctx context.Context, server string, id int) (*models.Tribe, error)
TribeChanges(ctx context.Context, server string, filter *models.TribeChangeFilter) (*TribeChanges, error)
TribeHistory(ctx context.Context, server string, filter *models.TribeHistoryFilter) (*TribeHistory, error)
Villages(ctx context.Context, server string, filter *models.VillageFilter) (*VillagesList, error)
Village(ctx context.Context, server string, id int) (*models.Village, error)
@ -504,6 +519,11 @@ type QueryResolver interface {
type ServerResolver interface {
LangVersion(ctx context.Context, obj *models.Server) (*models.LangVersion, error)
}
type TribeChangeRecordResolver interface {
Player(ctx context.Context, obj *models.TribeChange) (*models.Player, error)
OldTribe(ctx context.Context, obj *models.TribeChange) (*models.Tribe, error)
NewTribe(ctx context.Context, obj *models.TribeChange) (*models.Tribe, error)
}
type TribeHistoryRecordResolver interface {
Tribe(ctx context.Context, obj *models.TribeHistory) (*models.Tribe, error)
}
@ -1239,6 +1259,18 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Query.Tribe(childComplexity, args["server"].(string), args["id"].(int)), true
case "Query.tribeChanges":
if e.complexity.Query.TribeChanges == nil {
break
}
args, err := ec.field_Query_tribeChanges_args(context.TODO(), rawArgs)
if err != nil {
return 0, false
}
return e.complexity.Query.TribeChanges(childComplexity, args["server"].(string), args["filter"].(*models.TribeChangeFilter)), true
case "Query.tribeHistory":
if e.complexity.Query.TribeHistory == nil {
break
@ -2351,6 +2383,48 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Tribe.TotalVillages(childComplexity), true
case "TribeChangeRecord.createdAt":
if e.complexity.TribeChangeRecord.CreatedAt == nil {
break
}
return e.complexity.TribeChangeRecord.CreatedAt(childComplexity), true
case "TribeChangeRecord.newTribe":
if e.complexity.TribeChangeRecord.NewTribe == nil {
break
}
return e.complexity.TribeChangeRecord.NewTribe(childComplexity), true
case "TribeChangeRecord.oldTribe":
if e.complexity.TribeChangeRecord.OldTribe == nil {
break
}
return e.complexity.TribeChangeRecord.OldTribe(childComplexity), true
case "TribeChangeRecord.player":
if e.complexity.TribeChangeRecord.Player == nil {
break
}
return e.complexity.TribeChangeRecord.Player(childComplexity), true
case "TribeChanges.items":
if e.complexity.TribeChanges.Items == nil {
break
}
return e.complexity.TribeChanges.Items(childComplexity), true
case "TribeChanges.total":
if e.complexity.TribeChanges.Total == nil {
break
}
return e.complexity.TribeChanges.Total(childComplexity), true
case "TribeHistory.items":
if e.complexity.TribeHistory.Items == nil {
break
@ -3402,6 +3476,43 @@ extend type Query {
tribes(server: String!, filter: TribeFilter): TribesList!
tribe(server: String!, id: Int!): Tribe
}
`, BuiltIn: false},
&ast.Source{Name: "schema/tribe_change.graphql", Input: `type TribeChangeRecord {
player: Player @goField(forceResolver: true)
oldTribe: Tribe @goField(forceResolver: true)
newTribe: Tribe @goField(forceResolver: true)
createdAt: Time!
}
type TribeChanges {
total: Int!
items: [TribeChangeRecord!]
}
input TribeChangeFilter {
playerID: [Int!]
playerIDNEQ: [Int!]
oldTribeID: [Int!]
oldTribeIDNEQ: [Int!]
newTribeID: [Int!]
newTribeIDNEQ: [Int!]
createdAt: Time
createdAtGT: Time
createdAtGTE: Time
createdAtLT: Time
createdAtLTE: Time
offset: Int
limit: Int
sort: String
}
extend type Query {
tribeChanges(server: String!, filter: TribeChangeFilter): TribeChanges!
}
`, BuiltIn: false},
&ast.Source{Name: "schema/tribe_history.graphql", Input: `type TribeHistoryRecord {
tribe: Tribe @goField(forceResolver: true)
@ -3730,6 +3841,28 @@ func (ec *executionContext) field_Query_servers_args(ctx context.Context, rawArg
return args, nil
}
func (ec *executionContext) field_Query_tribeChanges_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
var err error
args := map[string]interface{}{}
var arg0 string
if tmp, ok := rawArgs["server"]; ok {
arg0, err = ec.unmarshalNString2string(ctx, tmp)
if err != nil {
return nil, err
}
}
args["server"] = arg0
var arg1 *models.TribeChangeFilter
if tmp, ok := rawArgs["filter"]; ok {
arg1, err = ec.unmarshalOTribeChangeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChangeFilter(ctx, tmp)
if err != nil {
return nil, err
}
}
args["filter"] = arg1
return args, nil
}
func (ec *executionContext) field_Query_tribeHistory_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
var err error
args := map[string]interface{}{}
@ -7130,6 +7263,47 @@ func (ec *executionContext) _Query_tribe(ctx context.Context, field graphql.Coll
return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx, field.Selections, res)
}
func (ec *executionContext) _Query_tribeChanges(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Query",
Field: field,
Args: nil,
IsMethod: true,
}
ctx = graphql.WithFieldContext(ctx, fc)
rawArgs := field.ArgumentMap(ec.Variables)
args, err := ec.field_Query_tribeChanges_args(ctx, rawArgs)
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
fc.Args = args
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return ec.resolvers.Query().TribeChanges(rctx, args["server"].(string), args["filter"].(*models.TribeChangeFilter))
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(*TribeChanges)
fc.Result = res
return ec.marshalNTribeChanges2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐTribeChanges(ctx, field.Selections, res)
}
func (ec *executionContext) _Query_tribeHistory(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
@ -12478,6 +12652,198 @@ func (ec *executionContext) _Tribe_scoreTotal(ctx context.Context, field graphql
return ec.marshalNInt2int(ctx, field.Selections, res)
}
func (ec *executionContext) _TribeChangeRecord_player(ctx context.Context, field graphql.CollectedField, obj *models.TribeChange) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "TribeChangeRecord",
Field: field,
Args: nil,
IsMethod: true,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return ec.resolvers.TribeChangeRecord().Player(rctx, obj)
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*models.Player)
fc.Result = res
return ec.marshalOPlayer2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐPlayer(ctx, field.Selections, res)
}
func (ec *executionContext) _TribeChangeRecord_oldTribe(ctx context.Context, field graphql.CollectedField, obj *models.TribeChange) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "TribeChangeRecord",
Field: field,
Args: nil,
IsMethod: true,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return ec.resolvers.TribeChangeRecord().OldTribe(rctx, obj)
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*models.Tribe)
fc.Result = res
return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx, field.Selections, res)
}
func (ec *executionContext) _TribeChangeRecord_newTribe(ctx context.Context, field graphql.CollectedField, obj *models.TribeChange) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "TribeChangeRecord",
Field: field,
Args: nil,
IsMethod: true,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return ec.resolvers.TribeChangeRecord().NewTribe(rctx, obj)
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*models.Tribe)
fc.Result = res
return ec.marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribe(ctx, field.Selections, res)
}
func (ec *executionContext) _TribeChangeRecord_createdAt(ctx context.Context, field graphql.CollectedField, obj *models.TribeChange) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "TribeChangeRecord",
Field: field,
Args: nil,
IsMethod: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.CreatedAt, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(time.Time)
fc.Result = res
return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}
func (ec *executionContext) _TribeChanges_total(ctx context.Context, field graphql.CollectedField, obj *TribeChanges) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "TribeChanges",
Field: field,
Args: nil,
IsMethod: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Total, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(int)
fc.Result = res
return ec.marshalNInt2int(ctx, field.Selections, res)
}
func (ec *executionContext) _TribeChanges_items(ctx context.Context, field graphql.CollectedField, obj *TribeChanges) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "TribeChanges",
Field: field,
Args: nil,
IsMethod: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Items, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.([]*models.TribeChange)
fc.Result = res
return ec.marshalOTribeChangeRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChangeᚄ(ctx, field.Selections, res)
}
func (ec *executionContext) _TribeHistory_total(ctx context.Context, field graphql.CollectedField, obj *TribeHistory) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
@ -16020,6 +16386,102 @@ func (ec *executionContext) unmarshalInputServerStatsFilter(ctx context.Context,
return it, nil
}
func (ec *executionContext) unmarshalInputTribeChangeFilter(ctx context.Context, obj interface{}) (models.TribeChangeFilter, error) {
var it models.TribeChangeFilter
var asMap = obj.(map[string]interface{})
for k, v := range asMap {
switch k {
case "playerID":
var err error
it.PlayerID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
if err != nil {
return it, err
}
case "playerIDNEQ":
var err error
it.PlayerIdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
if err != nil {
return it, err
}
case "oldTribeID":
var err error
it.OldTribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
if err != nil {
return it, err
}
case "oldTribeIDNEQ":
var err error
it.OldTribeIdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
if err != nil {
return it, err
}
case "newTribeID":
var err error
it.NewTribeID, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
if err != nil {
return it, err
}
case "newTribeIDNEQ":
var err error
it.NewTribeIdNEQ, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
if err != nil {
return it, err
}
case "createdAt":
var err error
it.CreatedAt, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
if err != nil {
return it, err
}
case "createdAtGT":
var err error
it.CreatedAtGT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
if err != nil {
return it, err
}
case "createdAtGTE":
var err error
it.CreatedAtGTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
if err != nil {
return it, err
}
case "createdAtLT":
var err error
it.CreatedAtLT, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
if err != nil {
return it, err
}
case "createdAtLTE":
var err error
it.CreatedAtLTE, err = ec.unmarshalOTime2timeᚐTime(ctx, v)
if err != nil {
return it, err
}
case "offset":
var err error
it.Offset, err = ec.unmarshalOInt2int(ctx, v)
if err != nil {
return it, err
}
case "limit":
var err error
it.Limit, err = ec.unmarshalOInt2int(ctx, v)
if err != nil {
return it, err
}
case "sort":
var err error
it.Sort, err = ec.unmarshalOString2string(ctx, v)
if err != nil {
return it, err
}
}
}
return it, nil
}
func (ec *executionContext) unmarshalInputTribeFilter(ctx context.Context, obj interface{}) (models.TribeFilter, error) {
var it models.TribeFilter
var asMap = obj.(map[string]interface{})
@ -17660,6 +18122,20 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr
res = ec._Query_tribe(ctx, field)
return res
})
case "tribeChanges":
field := field
out.Concurrently(i, func() (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
}
}()
res = ec._Query_tribeChanges(ctx, field)
if res == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
return res
})
case "tribeHistory":
field := field
out.Concurrently(i, func() (res graphql.Marshaler) {
@ -18892,6 +19368,95 @@ func (ec *executionContext) _Tribe(ctx context.Context, sel ast.SelectionSet, ob
return out
}
var tribeChangeRecordImplementors = []string{"TribeChangeRecord"}
func (ec *executionContext) _TribeChangeRecord(ctx context.Context, sel ast.SelectionSet, obj *models.TribeChange) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, tribeChangeRecordImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("TribeChangeRecord")
case "player":
field := field
out.Concurrently(i, func() (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
}
}()
res = ec._TribeChangeRecord_player(ctx, field, obj)
return res
})
case "oldTribe":
field := field
out.Concurrently(i, func() (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
}
}()
res = ec._TribeChangeRecord_oldTribe(ctx, field, obj)
return res
})
case "newTribe":
field := field
out.Concurrently(i, func() (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
}
}()
res = ec._TribeChangeRecord_newTribe(ctx, field, obj)
return res
})
case "createdAt":
out.Values[i] = ec._TribeChangeRecord_createdAt(ctx, field, obj)
if out.Values[i] == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
var tribeChangesImplementors = []string{"TribeChanges"}
func (ec *executionContext) _TribeChanges(ctx context.Context, sel ast.SelectionSet, obj *TribeChanges) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, tribeChangesImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("TribeChanges")
case "total":
out.Values[i] = ec._TribeChanges_total(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "items":
out.Values[i] = ec._TribeChanges_items(ctx, field, obj)
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
var tribeHistoryImplementors = []string{"TribeHistory"}
func (ec *executionContext) _TribeHistory(ctx context.Context, sel ast.SelectionSet, obj *TribeHistory) graphql.Marshaler {
@ -19929,6 +20494,34 @@ func (ec *executionContext) marshalNTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsha
return ec._Tribe(ctx, sel, v)
}
func (ec *executionContext) marshalNTribeChangeRecord2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChange(ctx context.Context, sel ast.SelectionSet, v models.TribeChange) graphql.Marshaler {
return ec._TribeChangeRecord(ctx, sel, &v)
}
func (ec *executionContext) marshalNTribeChangeRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChange(ctx context.Context, sel ast.SelectionSet, v *models.TribeChange) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
return ec._TribeChangeRecord(ctx, sel, v)
}
func (ec *executionContext) marshalNTribeChanges2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐTribeChanges(ctx context.Context, sel ast.SelectionSet, v TribeChanges) graphql.Marshaler {
return ec._TribeChanges(ctx, sel, &v)
}
func (ec *executionContext) marshalNTribeChanges2ᚖgithubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐTribeChanges(ctx context.Context, sel ast.SelectionSet, v *TribeChanges) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
return ec._TribeChanges(ctx, sel, v)
}
func (ec *executionContext) marshalNTribeHistory2githubᚗcomᚋtribalwarshelpᚋapiᚋgraphqlᚋgeneratedᚐTribeHistory(ctx context.Context, sel ast.SelectionSet, v TribeHistory) graphql.Marshaler {
return ec._TribeHistory(ctx, sel, &v)
}
@ -20915,6 +21508,58 @@ func (ec *executionContext) marshalOTribe2ᚖgithubᚗcomᚋtribalwarshelpᚋsha
return ec._Tribe(ctx, sel, v)
}
func (ec *executionContext) unmarshalOTribeChangeFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChangeFilter(ctx context.Context, v interface{}) (models.TribeChangeFilter, error) {
return ec.unmarshalInputTribeChangeFilter(ctx, v)
}
func (ec *executionContext) unmarshalOTribeChangeFilter2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChangeFilter(ctx context.Context, v interface{}) (*models.TribeChangeFilter, error) {
if v == nil {
return nil, nil
}
res, err := ec.unmarshalOTribeChangeFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChangeFilter(ctx, v)
return &res, err
}
func (ec *executionContext) marshalOTribeChangeRecord2ᚕᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChangeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.TribeChange) graphql.Marshaler {
if v == nil {
return graphql.Null
}
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
ret[i] = ec.marshalNTribeChangeRecord2ᚖgithubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeChange(ctx, sel, v[i])
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
func (ec *executionContext) unmarshalOTribeFilter2githubᚗcomᚋtribalwarshelpᚋsharedᚋmodelsᚐTribeFilter(ctx context.Context, v interface{}) (models.TribeFilter, error) {
return ec.unmarshalInputTribeFilter(ctx, v)
}

5
graphql/generated/models.go
View File

@ -36,6 +36,11 @@ type ServersList struct {
Total int `json:"total"`
}
type TribeChanges struct {
Total int `json:"total"`
Items []*models.TribeChange `json:"items"`
}
type TribeHistory struct {
Total int `json:"total"`
Items []*models.TribeHistory `json:"items"`

4
graphql/gqlgen.yml
View File

@ -90,3 +90,7 @@ models:
model: github.com/tribalwarshelp/shared/models.ServerStats
ServerStatsFilter:
model: github.com/tribalwarshelp/shared/models.ServerStatsFilter
TribeChangeRecord:
model: github.com/tribalwarshelp/shared/models.TribeChange
TribeChangeFilter:
model: github.com/tribalwarshelp/shared/models.TribeChangeFilter

6
graphql/resolvers/resolver.go
View File

@ -10,6 +10,7 @@ import (
"github.com/tribalwarshelp/api/server"
"github.com/tribalwarshelp/api/serverstats"
"github.com/tribalwarshelp/api/tribe"
"github.com/tribalwarshelp/api/tribechange"
"github.com/tribalwarshelp/api/tribehistory"
"github.com/tribalwarshelp/api/village"
)
@ -25,6 +26,7 @@ type Resolver struct {
PlayerHistoryUcase playerhistory.Usecase
TribeHistoryUcase tribehistory.Usecase
ServerStatsUcase serverstats.Usecase
TribeChangeUcase tribechange.Usecase
}
// Query returns generated.QueryResolver implementation.
@ -42,6 +44,9 @@ func (r *Resolver) PlayerHistoryRecord() generated.PlayerHistoryRecordResolver {
func (r *Resolver) TribeHistoryRecord() generated.TribeHistoryRecordResolver {
return &tribeHistoryRecordResolver{r}
}
func (r *Resolver) TribeChangeRecord() generated.TribeChangeRecordResolver {
return &tribeChangeRecordResolver{r}
}
type queryResolver struct{ *Resolver }
type playerResolver struct{ *Resolver }
@ -53,3 +58,4 @@ type serverResolver struct{ *Resolver }
type playerHistoryRecordResolver struct{ *Resolver }
type tribeHistoryRecordResolver struct{ *Resolver }
type serverStatsRecordResolver struct{ *Resolver }
type tribeChangeRecordResolver struct{ *Resolver }

39
graphql/resolvers/tribe_change.go Normal file
View File

@ -0,0 +1,39 @@
package resolvers
import (
"context"
"github.com/tribalwarshelp/api/graphql/generated"
"github.com/tribalwarshelp/shared/models"
)
func (r *tribeChangeRecordResolver) Player(ctx context.Context, obj *models.TribeChange) (*models.Player, error) {
if obj.Player != nil {
return obj.Player, nil
}
return getPlayer(ctx, obj.PlayerID), nil
}
func (r *tribeChangeRecordResolver) NewTribe(ctx context.Context, obj *models.TribeChange) (*models.Tribe, error) {
if obj.NewTribe != nil {
return obj.NewTribe, nil
}
return getTribe(ctx, obj.NewTribeID), nil
}
func (r *tribeChangeRecordResolver) OldTribe(ctx context.Context, obj *models.TribeChange) (*models.Tribe, error) {
if obj.OldTribe != nil {
return obj.OldTribe, nil
}
return getTribe(ctx, obj.OldTribeID), nil
}
func (r *Resolver) TribeChanges(ctx context.Context, server string, filter *models.TribeChangeFilter) (*generated.TribeChanges, error) {
var err error
list := &generated.TribeChanges{}
list.Items, list.Total, err = r.TribeChangeUcase.Fetch(ctx, server, filter)
return list, err
}

36
graphql/schema/tribe_change.graphql Normal file
View File

@ -0,0 +1,36 @@
type TribeChangeRecord {
player: Player @goField(forceResolver: true)
oldTribe: Tribe @goField(forceResolver: true)
newTribe: Tribe @goField(forceResolver: true)
createdAt: Time!
}
type TribeChanges {
total: Int!
items: [TribeChangeRecord!]
}
input TribeChangeFilter {
playerID: [Int!]
playerIDNEQ: [Int!]
oldTribeID: [Int!]
oldTribeIDNEQ: [Int!]
newTribeID: [Int!]
newTribeIDNEQ: [Int!]
createdAt: Time
createdAtGT: Time
createdAtGTE: Time
createdAtLT: Time
createdAtLTE: Time
offset: Int
limit: Int
sort: String
}
extend type Query {
tribeChanges(server: String!, filter: TribeChangeFilter): TribeChanges!
}

9
main.go
View File

@ -37,6 +37,8 @@ import (
serverstatsucase "github.com/tribalwarshelp/api/serverstats/usecase"
triberepo "github.com/tribalwarshelp/api/tribe/repository"
tribeucase "github.com/tribalwarshelp/api/tribe/usecase"
tribechangerepo "github.com/tribalwarshelp/api/tribechange/repository"
tribechangeucase "github.com/tribalwarshelp/api/tribechange/usecase"
tribehistoryrepo "github.com/tribalwarshelp/api/tribehistory/repository"
tribehistoryucase "github.com/tribalwarshelp/api/tribehistory/usecase"
villagerepo "github.com/tribalwarshelp/api/village/repository"
@ -73,10 +75,11 @@ func main() {
Addr: os.Getenv("REDIS_HOST") + ":" + os.Getenv("REDIS_PORT"),
Password: os.Getenv("REDIS_PASSWORD"),
})
ctx, _ := context.WithTimeout(context.Background(), time.Second*5)
ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
if err := redisClient.Ping(ctx).Err(); err != nil {
log.Fatal(errors.Wrap(err, "cannot connect to redis"))
}
cancel()
defer func() {
if err := redisClient.Close(); err != nil {
log.Fatal(err)
@ -98,6 +101,7 @@ func main() {
tribehistoryRepo := tribehistoryrepo.NewPGRepository(db)
playerhistoryRepo := playerhistoryrepo.NewPGRepository(db)
serverstatsRepo := serverstatsrepo.NewPGRepository(db)
tribeChangeRepo := tribechangerepo.NewPGRepository(db)
liveennoblementRepo := liveennoblementrepo.NewPGRepository(db, redisClient)
serverUcase := serverucase.New(serverRepo)
@ -129,6 +133,7 @@ func main() {
TribeHistoryUcase: tribehistoryucase.New(tribehistoryRepo),
PlayerHistoryUcase: playerhistoryucase.New(playerhistoryRepo),
ServerStatsUcase: serverstatsucase.New(serverstatsRepo),
TribeChangeUcase: tribechangeucase.New(tribeChangeRepo),
},
})
@ -149,7 +154,7 @@ func main() {
<-quit
log.Println("Shutdown Server ...")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
ctx, cancel = context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := srv.Shutdown(ctx); err != nil {
log.Fatal("Server Shutdown:", err)

5
tribechange/constants.go Normal file
View File

@ -0,0 +1,5 @@
package tribechange
const (
PaginationLimit = 100
)

17
tribechange/repository.go Normal file
View File

@ -0,0 +1,17 @@
package tribechange
import (
"context"
"github.com/tribalwarshelp/shared/models"
)
type FetchConfig struct {
Server string
Filter *models.TribeChangeFilter
Count bool
}
type Repository interface {
Fetch(ctx context.Context, cfg FetchConfig) ([]*models.TribeChange, int, error)
}

52
tribechange/repository/pg_repository.go Normal file
View File

@ -0,0 +1,52 @@
package repository
import (
"context"
"fmt"
"strings"
"github.com/go-pg/pg/v10"
"github.com/pkg/errors"
"github.com/tribalwarshelp/api/tribechange"
"github.com/tribalwarshelp/shared/models"
)
type pgRepository struct {
*pg.DB
}
func NewPGRepository(db *pg.DB) tribechange.Repository {
return &pgRepository{db}
}
func (repo *pgRepository) Fetch(ctx context.Context, cfg tribechange.FetchConfig) ([]*models.TribeChange, int, error) {
var err error
total := 0
data := []*models.TribeChange{}
query := repo.WithParam("SERVER", pg.Safe(cfg.Server)).Model(&data).Context(ctx)
if cfg.Filter != nil {
query = query.
WhereStruct(cfg.Filter).
Limit(cfg.Filter.Limit).
Offset(cfg.Filter.Offset)
if cfg.Filter.Sort != "" {
query = query.Order(cfg.Filter.Sort)
}
}
if cfg.Count {
total, err = query.SelectAndCount()
} else {
err = query.Select()
}
if err != nil && err != pg.ErrNoRows {
if strings.Contains(err.Error(), `relation "`+cfg.Server) {
return nil, 0, fmt.Errorf("Server not found")
}
return nil, 0, errors.Wrap(err, "Internal server error")
}
return data, total, nil
}

11
tribechange/usecase.go Normal file
View File

@ -0,0 +1,11 @@
package tribechange
import (
"context"
"github.com/tribalwarshelp/shared/models"
)
type Usecase interface {
Fetch(ctx context.Context, server string, filter *models.TribeChangeFilter) ([]*models.TribeChange, int, error)
}

32
tribechange/usecase/tribechange_usecase.go Normal file
View File

@ -0,0 +1,32 @@
package usecase
import (
"context"
"github.com/tribalwarshelp/api/tribechange"
"github.com/tribalwarshelp/api/utils"
"github.com/tribalwarshelp/shared/models"
)
type usecase struct {
repo tribechange.Repository
}
func New(repo tribechange.Repository) tribechange.Usecase {
return &usecase{repo}
}
func (ucase *usecase) Fetch(ctx context.Context, server string, filter *models.TribeChangeFilter) ([]*models.TribeChange, int, error) {
if filter == nil {
filter = &models.TribeChangeFilter{}
}
if filter.Limit > tribechange.PaginationLimit || filter.Limit <= 0 {
filter.Limit = tribechange.PaginationLimit
}
filter.Sort = utils.SanitizeSort(filter.Sort)
return ucase.repo.Fetch(ctx, tribechange.FetchConfig{
Server: server,
Filter: filter,
Count: true,
})
}