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

resolvers refactor (add 3 new helpers - safeStrPointer, safeIntPointer and shouldCount)

This commit is contained in:
Dawid Wysokiński 2020-12-25 12:13:12 +01:00
parent 4bccaab85d
commit 4a58bff0f6
13 changed files with 38 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
graphql/resolvers/daily_player_stats.go
View File

@ -22,24 +22,15 @@ func (r *queryResolver) DailyPlayerStats(ctx context.Context,
limit *int,
offset *int,
sort []string) (*generated.DailyPlayerStats, error) {
defLimit := 0
defOffset := 0
if limit == nil {
limit = &defLimit
}
if offset == nil {
offset = &defOffset
}
var err error
list := &generated.DailyPlayerStats{}
list.Items, list.Total, err = r.DailyPlayerStatsUcase.Fetch(ctx, dailyplayerstats.FetchConfig{
Server: server,
Filter: filter,
Sort: sort,
Limit: *limit,
Offset: *offset,
Count: true,
Limit: safeIntPointer(limit, 0),
Offset: safeIntPointer(offset, 0),
Count: shouldCount(ctx),
})
return list, err
}

15
graphql/resolvers/daily_tribe_stats.go
View File

@ -22,24 +22,15 @@ func (r *queryResolver) DailyTribeStats(ctx context.Context,
limit *int,
offset *int,
sort []string) (*generated.DailyTribeStats, error) {
defLimit := 0
defOffset := 0
if limit == nil {
limit = &defLimit
}
if offset == nil {
offset = &defOffset
}
var err error
list := &generated.DailyTribeStats{}
list.Items, list.Total, err = r.DailyTribeStatsUcase.Fetch(ctx, dailytribestats.FetchConfig{
Server: server,
Filter: filter,
Sort: sort,
Limit: *limit,
Offset: *offset,
Count: true,
Limit: safeIntPointer(limit, 0),
Offset: safeIntPointer(offset, 0),
Count: shouldCount(ctx),
})
return list, err
}

15
graphql/resolvers/ennoblement.go
View File

@ -53,24 +53,15 @@ func (r *queryResolver) Ennoblements(ctx context.Context, server string,
limit *int,
offset *int,
sort []string) (*generated.EnnoblementList, error) {
defLimit := 0
defOffset := 0
if limit == nil {
limit = &defLimit
}
if offset == nil {
offset = &defOffset
}
var err error
list := &generated.EnnoblementList{}
list.Items, list.Total, err = r.EnnoblementUcase.Fetch(ctx, ennoblement.FetchConfig{
Server: server,
Filter: f,
Sort: sort,
Limit: *limit,
Offset: *offset,
Count: true,
Limit: safeIntPointer(limit, 0),
Offset: safeIntPointer(offset, 0),
Count: shouldCount(ctx),
})
return list, err
}

6
graphql/resolvers/helpers.go
View File

@ -68,14 +68,12 @@ func getTribe(ctx context.Context, id int) *models.Tribe {
}
func shouldCount(ctx context.Context) bool {
count := false
for _, field := range graphql.CollectFieldsCtx(ctx, nil) {
if field.Name == countField {
count = true
break
return true
}
}
return count
return false
}
func safeStrPointer(s *string, def string) string {

15
graphql/resolvers/player.go
View File

@ -52,24 +52,15 @@ func (r *queryResolver) Players(ctx context.Context,
limit *int,
offset *int,
sort []string) (*generated.PlayerList, error) {
defLimit := 0
defOffset := 0
if limit == nil {
limit = &defLimit
}
if offset == nil {
offset = &defOffset
}
var err error
list := &generated.PlayerList{}
list.Items, list.Total, err = r.PlayerUcase.Fetch(ctx, player.FetchConfig{
Server: server,
Filter: f,
Sort: sort,
Limit: *limit,
Offset: *offset,
Count: true,
Limit: safeIntPointer(limit, 0),
Offset: safeIntPointer(offset, 0),
Count: shouldCount(ctx),
})
return list, err
}

15
graphql/resolvers/player_history.go
View File

@ -30,24 +30,15 @@ func (r *Resolver) PlayerHistory(ctx context.Context,
limit *int,
offset *int,
sort []string) (*generated.PlayerHistory, error) {
defLimit := 0
defOffset := 0
if limit == nil {
limit = &defLimit
}
if offset == nil {
offset = &defOffset
}
var err error
list := &generated.PlayerHistory{}
list.Items, list.Total, err = r.PlayerHistoryUcase.Fetch(ctx, playerhistory.FetchConfig{
Server: server,
Filter: f,
Sort: sort,
Limit: *limit,
Offset: *offset,
Count: true,
Limit: safeIntPointer(limit, 0),
Offset: safeIntPointer(offset, 0),
Count: shouldCount(ctx),
})
return list, err
}

15
graphql/resolvers/server.go
View File

@ -28,23 +28,14 @@ func (r *queryResolver) Servers(ctx context.Context,
limit *int,
offset *int,
sort []string) (*generated.ServerList, error) {
defLimit := 0
defOffset := 0
if limit == nil {
limit = &defLimit
}
if offset == nil {
offset = &defOffset
}
var err error
list := &generated.ServerList{}
list.Items, list.Total, err = r.ServerUcase.Fetch(ctx, server.FetchConfig{
Filter: f,
Sort: sort,
Limit: *limit,
Offset: *offset,
Count: true,
Limit: safeIntPointer(limit, 0),
Offset: safeIntPointer(offset, 0),
Count: shouldCount(ctx),
})
return list, err
}

15
graphql/resolvers/server_stats.go
View File

@ -14,24 +14,15 @@ func (r *Resolver) ServerStats(ctx context.Context,
limit *int,
offset *int,
sort []string) (*generated.ServerStats, error) {
defLimit := 0
defOffset := 0
if limit == nil {
limit = &defLimit
}
if offset == nil {
offset = &defOffset
}
var err error
list := &generated.ServerStats{}
list.Items, list.Total, err = r.ServerStatsUcase.Fetch(ctx, serverstats.FetchConfig{
Server: server,
Filter: f,
Sort: sort,
Limit: *limit,
Offset: *offset,
Count: true,
Limit: safeIntPointer(limit, 0),
Offset: safeIntPointer(offset, 0),
Count: shouldCount(ctx),
})
return list, err
}

15
graphql/resolvers/tribe.go
View File

@ -14,24 +14,15 @@ func (r *queryResolver) Tribes(ctx context.Context,
limit *int,
offset *int,
sort []string) (*generated.TribeList, error) {
defLimit := 0
defOffset := 0
if limit == nil {
limit = &defLimit
}
if offset == nil {
offset = &defOffset
}
var err error
list := &generated.TribeList{}
list.Items, list.Total, err = r.TribeUcase.Fetch(ctx, tribe.FetchConfig{
Server: server,
Filter: f,
Sort: sort,
Limit: *limit,
Offset: *offset,
Count: true,
Limit: safeIntPointer(limit, 0),
Offset: safeIntPointer(offset, 0),
Count: shouldCount(ctx),
})
return list, err
}

15
graphql/resolvers/tribe_change.go
View File

@ -38,23 +38,14 @@ func (r *Resolver) TribeChanges(ctx context.Context,
limit *int,
offset *int,
sort []string) (*generated.TribeChanges, error) {
defLimit := 0
defOffset := 0
if limit == nil {
limit = &defLimit
}
if offset == nil {
offset = &defOffset
}
var err error
list := &generated.TribeChanges{}
list.Items, list.Total, err = r.TribeChangeUcase.Fetch(ctx, tribechange.FetchConfig{
Filter: f,
Sort: sort,
Limit: *limit,
Offset: *offset,
Count: true,
Limit: safeIntPointer(limit, 0),
Offset: safeIntPointer(offset, 0),
Count: shouldCount(ctx),
Server: server,
})
return list, err

15
graphql/resolvers/tribe_history.go
View File

@ -22,23 +22,14 @@ func (r *Resolver) TribeHistory(ctx context.Context,
limit *int,
offset *int,
sort []string) (*generated.TribeHistory, error) {
defLimit := 0
defOffset := 0
if limit == nil {
limit = &defLimit
}
if offset == nil {
offset = &defOffset
}
var err error
list := &generated.TribeHistory{}
list.Items, list.Total, err = r.TribeHistoryUcase.Fetch(ctx, tribehistory.FetchConfig{
Filter: f,
Sort: sort,
Limit: *limit,
Offset: *offset,
Count: true,
Limit: safeIntPointer(limit, 0),
Offset: safeIntPointer(offset, 0),
Count: shouldCount(ctx),
Server: server,
})
return list, err

15
graphql/resolvers/version.go
View File

@ -17,23 +17,14 @@ func (r *queryResolver) Versions(ctx context.Context,
limit *int,
offset *int,
sort []string) (*generated.VersionList, error) {
defLimit := 0
defOffset := 0
if limit == nil {
limit = &defLimit
}
if offset == nil {
offset = &defOffset
}
var err error
list := &generated.VersionList{}
list.Items, list.Total, err = r.VersionUcase.Fetch(ctx, version.FetchConfig{
Filter: f,
Sort: sort,
Limit: *limit,
Offset: *offset,
Count: true,
Limit: safeIntPointer(limit, 0),
Offset: safeIntPointer(offset, 0),
Count: shouldCount(ctx),
})
return list, err
}

15
graphql/resolvers/village.go
View File

@ -22,23 +22,14 @@ func (r *queryResolver) Villages(ctx context.Context,
limit *int,
offset *int,
sort []string) (*generated.VillageList, error) {
defLimit := 0
defOffset := 0
if limit == nil {
limit = &defLimit
}
if offset == nil {
offset = &defOffset
}
var err error
list := &generated.VillageList{}
list.Items, list.Total, err = r.VillageUcase.Fetch(ctx, village.FetchConfig{
Filter: f,
Sort: sort,
Limit: *limit,
Offset: *offset,
Count: true,
Limit: safeIntPointer(limit, 0),
Offset: safeIntPointer(offset, 0),
Count: shouldCount(ctx),
Server: server,
})
return list, err