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)

Browse Source
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, limit *int,
offset *int, offset *int,
sort []string) (*generated.DailyPlayerStats, error) { sort []string) (*generated.DailyPlayerStats, error) {
defLimit := 0
defOffset := 0
if limit == nil {
limit = &defLimit
}
if offset == nil {
offset = &defOffset
}
var err error var err error
list := &generated.DailyPlayerStats{} list := &generated.DailyPlayerStats{}
list.Items, list.Total, err = r.DailyPlayerStatsUcase.Fetch(ctx, dailyplayerstats.FetchConfig{ list.Items, list.Total, err = r.DailyPlayerStatsUcase.Fetch(ctx, dailyplayerstats.FetchConfig{
Server: server, Server: server,
Filter: filter, Filter: filter,
Sort: sort, Sort: sort,
Limit: *limit, Limit: safeIntPointer(limit, 0),
Offset: *offset, Offset: safeIntPointer(offset, 0),
Count: true, Count: shouldCount(ctx),
}) })
return list, err 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, limit *int,
offset *int, offset *int,
sort []string) (*generated.DailyTribeStats, error) { sort []string) (*generated.DailyTribeStats, error) {
defLimit := 0
defOffset := 0
if limit == nil {
limit = &defLimit
}
if offset == nil {
offset = &defOffset
}
var err error var err error
list := &generated.DailyTribeStats{} list := &generated.DailyTribeStats{}
list.Items, list.Total, err = r.DailyTribeStatsUcase.Fetch(ctx, dailytribestats.FetchConfig{ list.Items, list.Total, err = r.DailyTribeStatsUcase.Fetch(ctx, dailytribestats.FetchConfig{
Server: server, Server: server,
Filter: filter, Filter: filter,
Sort: sort, Sort: sort,
Limit: *limit, Limit: safeIntPointer(limit, 0),
Offset: *offset, Offset: safeIntPointer(offset, 0),
Count: true, Count: shouldCount(ctx),
}) })
return list, err 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, limit *int,
offset *int, offset *int,
sort []string) (*generated.EnnoblementList, error) { sort []string) (*generated.EnnoblementList, error) {
defLimit := 0
defOffset := 0
if limit == nil {
limit = &defLimit
}
if offset == nil {
offset = &defOffset
}
var err error var err error
list := &generated.EnnoblementList{} list := &generated.EnnoblementList{}
list.Items, list.Total, err = r.EnnoblementUcase.Fetch(ctx, ennoblement.FetchConfig{ list.Items, list.Total, err = r.EnnoblementUcase.Fetch(ctx, ennoblement.FetchConfig{
Server: server, Server: server,
Filter: f, Filter: f,
Sort: sort, Sort: sort,
Limit: *limit, Limit: safeIntPointer(limit, 0),
Offset: *offset, Offset: safeIntPointer(offset, 0),
Count: true, Count: shouldCount(ctx),
}) })
return list, err 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 { func shouldCount(ctx context.Context) bool {
count := false
for _, field := range graphql.CollectFieldsCtx(ctx, nil) { for _, field := range graphql.CollectFieldsCtx(ctx, nil) {
if field.Name == countField { if field.Name == countField {
count = true return true
break
} }
} }
return count return false
} }
func safeStrPointer(s *string, def string) string { 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, limit *int,
offset *int, offset *int,
sort []string) (*generated.PlayerList, error) { sort []string) (*generated.PlayerList, error) {
defLimit := 0
defOffset := 0
if limit == nil {
limit = &defLimit
}
if offset == nil {
offset = &defOffset
}
var err error var err error
list := &generated.PlayerList{} list := &generated.PlayerList{}
list.Items, list.Total, err = r.PlayerUcase.Fetch(ctx, player.FetchConfig{ list.Items, list.Total, err = r.PlayerUcase.Fetch(ctx, player.FetchConfig{
Server: server, Server: server,
Filter: f, Filter: f,
Sort: sort, Sort: sort,
Limit: *limit, Limit: safeIntPointer(limit, 0),
Offset: *offset, Offset: safeIntPointer(offset, 0),
Count: true, Count: shouldCount(ctx),
}) })
return list, err return list, err
} }

15
graphql/resolvers/player_history.go
View File

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

15
graphql/resolvers/server.go
View File

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

15
graphql/resolvers/server_stats.go
View File

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

15
graphql/resolvers/tribe.go
View File

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

15
graphql/resolvers/tribe_change.go
View File

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

15
graphql/resolvers/tribe_history.go
View File

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

15
graphql/resolvers/version.go
View File

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

15
graphql/resolvers/village.go
View File

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