2020-04-10 04:40:22 +02:00
|
|
|
// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
|
|
|
|
|
|
|
|
package graph
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"context"
|
|
|
|
"errors"
|
|
|
|
"strconv"
|
|
|
|
"sync"
|
|
|
|
"sync/atomic"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/99designs/gqlgen/graphql"
|
|
|
|
"github.com/99designs/gqlgen/graphql/introspection"
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"github.com/jordanknott/project-citadel/api/pg"
|
|
|
|
gqlparser "github.com/vektah/gqlparser/v2"
|
|
|
|
"github.com/vektah/gqlparser/v2/ast"
|
|
|
|
)
|
|
|
|
|
|
|
|
// region ************************** generated!.gotpl **************************
|
|
|
|
|
|
|
|
// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
|
|
|
|
func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
|
|
|
|
return &executableSchema{
|
|
|
|
resolvers: cfg.Resolvers,
|
|
|
|
directives: cfg.Directives,
|
|
|
|
complexity: cfg.Complexity,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type Config struct {
|
|
|
|
Resolvers ResolverRoot
|
|
|
|
Directives DirectiveRoot
|
|
|
|
Complexity ComplexityRoot
|
|
|
|
}
|
|
|
|
|
|
|
|
type ResolverRoot interface {
|
|
|
|
Mutation() MutationResolver
|
|
|
|
Organization() OrganizationResolver
|
|
|
|
Project() ProjectResolver
|
|
|
|
Query() QueryResolver
|
|
|
|
Task() TaskResolver
|
|
|
|
TaskGroup() TaskGroupResolver
|
|
|
|
Team() TeamResolver
|
|
|
|
}
|
|
|
|
|
|
|
|
type DirectiveRoot struct {
|
|
|
|
}
|
|
|
|
|
|
|
|
type ComplexityRoot struct {
|
|
|
|
DeleteTaskPayload struct {
|
|
|
|
TaskID func(childComplexity int) int
|
|
|
|
}
|
|
|
|
|
|
|
|
Mutation struct {
|
|
|
|
CreateOrganization func(childComplexity int, input NewOrganization) int
|
|
|
|
CreateProject func(childComplexity int, input NewProject) int
|
|
|
|
CreateRefreshToken func(childComplexity int, input NewRefreshToken) int
|
|
|
|
CreateTask func(childComplexity int, input NewTask) int
|
|
|
|
CreateTaskGroup func(childComplexity int, input NewTaskGroup) int
|
|
|
|
CreateTeam func(childComplexity int, input NewTeam) int
|
|
|
|
CreateUserAccount func(childComplexity int, input NewUserAccount) int
|
|
|
|
DeleteTask func(childComplexity int, input DeleteTaskInput) int
|
|
|
|
LogoutUser func(childComplexity int, input LogoutUser) int
|
|
|
|
UpdateTaskLocation func(childComplexity int, input NewTaskLocation) int
|
|
|
|
UpdateTaskName func(childComplexity int, input UpdateTaskName) int
|
|
|
|
}
|
|
|
|
|
|
|
|
Organization struct {
|
|
|
|
CreatedAt func(childComplexity int) int
|
|
|
|
Name func(childComplexity int) int
|
|
|
|
OrganizationID func(childComplexity int) int
|
|
|
|
Teams func(childComplexity int) int
|
|
|
|
}
|
|
|
|
|
|
|
|
Project struct {
|
|
|
|
CreatedAt func(childComplexity int) int
|
|
|
|
Name func(childComplexity int) int
|
|
|
|
ProjectID func(childComplexity int) int
|
|
|
|
TaskGroups func(childComplexity int) int
|
|
|
|
TeamID func(childComplexity int) int
|
|
|
|
}
|
|
|
|
|
|
|
|
Query struct {
|
|
|
|
FindProject func(childComplexity int, input FindProject) int
|
|
|
|
FindUser func(childComplexity int, input FindUser) int
|
|
|
|
Organizations func(childComplexity int) int
|
|
|
|
Projects func(childComplexity int, input *ProjectsFilter) int
|
|
|
|
TaskGroups func(childComplexity int) int
|
|
|
|
Teams func(childComplexity int) int
|
|
|
|
Users func(childComplexity int) int
|
|
|
|
}
|
|
|
|
|
|
|
|
RefreshToken struct {
|
|
|
|
CreatedAt func(childComplexity int) int
|
|
|
|
ExpiresAt func(childComplexity int) int
|
|
|
|
TokenID func(childComplexity int) int
|
|
|
|
UserID func(childComplexity int) int
|
|
|
|
}
|
|
|
|
|
|
|
|
Task struct {
|
2020-04-11 04:22:22 +02:00
|
|
|
CreatedAt func(childComplexity int) int
|
|
|
|
Name func(childComplexity int) int
|
|
|
|
Position func(childComplexity int) int
|
|
|
|
TaskGroup func(childComplexity int) int
|
|
|
|
TaskID func(childComplexity int) int
|
2020-04-10 04:40:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
TaskGroup struct {
|
|
|
|
CreatedAt func(childComplexity int) int
|
|
|
|
Name func(childComplexity int) int
|
|
|
|
Position func(childComplexity int) int
|
|
|
|
ProjectID func(childComplexity int) int
|
|
|
|
TaskGroupID func(childComplexity int) int
|
|
|
|
Tasks func(childComplexity int) int
|
|
|
|
}
|
|
|
|
|
|
|
|
Team struct {
|
|
|
|
CreatedAt func(childComplexity int) int
|
|
|
|
Name func(childComplexity int) int
|
|
|
|
Projects func(childComplexity int) int
|
|
|
|
TeamID func(childComplexity int) int
|
|
|
|
}
|
|
|
|
|
|
|
|
UserAccount struct {
|
|
|
|
CreatedAt func(childComplexity int) int
|
|
|
|
DisplayName func(childComplexity int) int
|
|
|
|
Email func(childComplexity int) int
|
|
|
|
UserID func(childComplexity int) int
|
|
|
|
Username func(childComplexity int) int
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type MutationResolver interface {
|
|
|
|
CreateRefreshToken(ctx context.Context, input NewRefreshToken) (*pg.RefreshToken, error)
|
|
|
|
CreateUserAccount(ctx context.Context, input NewUserAccount) (*pg.UserAccount, error)
|
|
|
|
CreateOrganization(ctx context.Context, input NewOrganization) (*pg.Organization, error)
|
|
|
|
CreateTeam(ctx context.Context, input NewTeam) (*pg.Team, error)
|
|
|
|
CreateProject(ctx context.Context, input NewProject) (*pg.Project, error)
|
|
|
|
CreateTaskGroup(ctx context.Context, input NewTaskGroup) (*pg.TaskGroup, error)
|
|
|
|
CreateTask(ctx context.Context, input NewTask) (*pg.Task, error)
|
|
|
|
UpdateTaskLocation(ctx context.Context, input NewTaskLocation) (*pg.Task, error)
|
|
|
|
LogoutUser(ctx context.Context, input LogoutUser) (bool, error)
|
|
|
|
UpdateTaskName(ctx context.Context, input UpdateTaskName) (*pg.Task, error)
|
|
|
|
DeleteTask(ctx context.Context, input DeleteTaskInput) (*DeleteTaskPayload, error)
|
|
|
|
}
|
|
|
|
type OrganizationResolver interface {
|
|
|
|
Teams(ctx context.Context, obj *pg.Organization) ([]pg.Team, error)
|
|
|
|
}
|
|
|
|
type ProjectResolver interface {
|
|
|
|
TeamID(ctx context.Context, obj *pg.Project) (string, error)
|
|
|
|
|
|
|
|
TaskGroups(ctx context.Context, obj *pg.Project) ([]pg.TaskGroup, error)
|
|
|
|
}
|
|
|
|
type QueryResolver interface {
|
|
|
|
Organizations(ctx context.Context) ([]pg.Organization, error)
|
|
|
|
Users(ctx context.Context) ([]pg.UserAccount, error)
|
|
|
|
FindUser(ctx context.Context, input FindUser) (*pg.UserAccount, error)
|
|
|
|
FindProject(ctx context.Context, input FindProject) (*pg.Project, error)
|
|
|
|
Teams(ctx context.Context) ([]pg.Team, error)
|
|
|
|
Projects(ctx context.Context, input *ProjectsFilter) ([]pg.Project, error)
|
|
|
|
TaskGroups(ctx context.Context) ([]pg.TaskGroup, error)
|
|
|
|
}
|
|
|
|
type TaskResolver interface {
|
2020-04-11 04:22:22 +02:00
|
|
|
TaskGroup(ctx context.Context, obj *pg.Task) (*pg.TaskGroup, error)
|
2020-04-10 04:40:22 +02:00
|
|
|
}
|
|
|
|
type TaskGroupResolver interface {
|
|
|
|
ProjectID(ctx context.Context, obj *pg.TaskGroup) (string, error)
|
|
|
|
|
|
|
|
Tasks(ctx context.Context, obj *pg.TaskGroup) ([]pg.Task, error)
|
|
|
|
}
|
|
|
|
type TeamResolver interface {
|
|
|
|
Projects(ctx context.Context, obj *pg.Team) ([]pg.Project, error)
|
|
|
|
}
|
|
|
|
|
|
|
|
type executableSchema struct {
|
|
|
|
resolvers ResolverRoot
|
|
|
|
directives DirectiveRoot
|
|
|
|
complexity ComplexityRoot
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e *executableSchema) Schema() *ast.Schema {
|
|
|
|
return parsedSchema
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
|
|
|
|
ec := executionContext{nil, e}
|
|
|
|
_ = ec
|
|
|
|
switch typeName + "." + field {
|
|
|
|
|
|
|
|
case "DeleteTaskPayload.taskID":
|
|
|
|
if e.complexity.DeleteTaskPayload.TaskID == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.DeleteTaskPayload.TaskID(childComplexity), true
|
|
|
|
|
|
|
|
case "Mutation.createOrganization":
|
|
|
|
if e.complexity.Mutation.CreateOrganization == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Mutation_createOrganization_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Mutation.CreateOrganization(childComplexity, args["input"].(NewOrganization)), true
|
|
|
|
|
|
|
|
case "Mutation.createProject":
|
|
|
|
if e.complexity.Mutation.CreateProject == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Mutation_createProject_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Mutation.CreateProject(childComplexity, args["input"].(NewProject)), true
|
|
|
|
|
|
|
|
case "Mutation.createRefreshToken":
|
|
|
|
if e.complexity.Mutation.CreateRefreshToken == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Mutation_createRefreshToken_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Mutation.CreateRefreshToken(childComplexity, args["input"].(NewRefreshToken)), true
|
|
|
|
|
|
|
|
case "Mutation.createTask":
|
|
|
|
if e.complexity.Mutation.CreateTask == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Mutation_createTask_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Mutation.CreateTask(childComplexity, args["input"].(NewTask)), true
|
|
|
|
|
|
|
|
case "Mutation.createTaskGroup":
|
|
|
|
if e.complexity.Mutation.CreateTaskGroup == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Mutation_createTaskGroup_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Mutation.CreateTaskGroup(childComplexity, args["input"].(NewTaskGroup)), true
|
|
|
|
|
|
|
|
case "Mutation.createTeam":
|
|
|
|
if e.complexity.Mutation.CreateTeam == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Mutation_createTeam_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Mutation.CreateTeam(childComplexity, args["input"].(NewTeam)), true
|
|
|
|
|
|
|
|
case "Mutation.createUserAccount":
|
|
|
|
if e.complexity.Mutation.CreateUserAccount == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Mutation_createUserAccount_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Mutation.CreateUserAccount(childComplexity, args["input"].(NewUserAccount)), true
|
|
|
|
|
|
|
|
case "Mutation.deleteTask":
|
|
|
|
if e.complexity.Mutation.DeleteTask == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Mutation_deleteTask_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Mutation.DeleteTask(childComplexity, args["input"].(DeleteTaskInput)), true
|
|
|
|
|
|
|
|
case "Mutation.logoutUser":
|
|
|
|
if e.complexity.Mutation.LogoutUser == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Mutation_logoutUser_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Mutation.LogoutUser(childComplexity, args["input"].(LogoutUser)), true
|
|
|
|
|
|
|
|
case "Mutation.updateTaskLocation":
|
|
|
|
if e.complexity.Mutation.UpdateTaskLocation == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Mutation_updateTaskLocation_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Mutation.UpdateTaskLocation(childComplexity, args["input"].(NewTaskLocation)), true
|
|
|
|
|
|
|
|
case "Mutation.updateTaskName":
|
|
|
|
if e.complexity.Mutation.UpdateTaskName == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Mutation_updateTaskName_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Mutation.UpdateTaskName(childComplexity, args["input"].(UpdateTaskName)), true
|
|
|
|
|
|
|
|
case "Organization.createdAt":
|
|
|
|
if e.complexity.Organization.CreatedAt == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Organization.CreatedAt(childComplexity), true
|
|
|
|
|
|
|
|
case "Organization.name":
|
|
|
|
if e.complexity.Organization.Name == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Organization.Name(childComplexity), true
|
|
|
|
|
|
|
|
case "Organization.organizationID":
|
|
|
|
if e.complexity.Organization.OrganizationID == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Organization.OrganizationID(childComplexity), true
|
|
|
|
|
|
|
|
case "Organization.teams":
|
|
|
|
if e.complexity.Organization.Teams == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Organization.Teams(childComplexity), true
|
|
|
|
|
|
|
|
case "Project.createdAt":
|
|
|
|
if e.complexity.Project.CreatedAt == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Project.CreatedAt(childComplexity), true
|
|
|
|
|
|
|
|
case "Project.name":
|
|
|
|
if e.complexity.Project.Name == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Project.Name(childComplexity), true
|
|
|
|
|
|
|
|
case "Project.projectID":
|
|
|
|
if e.complexity.Project.ProjectID == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Project.ProjectID(childComplexity), true
|
|
|
|
|
|
|
|
case "Project.taskGroups":
|
|
|
|
if e.complexity.Project.TaskGroups == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Project.TaskGroups(childComplexity), true
|
|
|
|
|
|
|
|
case "Project.teamID":
|
|
|
|
if e.complexity.Project.TeamID == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Project.TeamID(childComplexity), true
|
|
|
|
|
|
|
|
case "Query.findProject":
|
|
|
|
if e.complexity.Query.FindProject == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Query_findProject_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Query.FindProject(childComplexity, args["input"].(FindProject)), true
|
|
|
|
|
|
|
|
case "Query.findUser":
|
|
|
|
if e.complexity.Query.FindUser == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Query_findUser_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Query.FindUser(childComplexity, args["input"].(FindUser)), true
|
|
|
|
|
|
|
|
case "Query.organizations":
|
|
|
|
if e.complexity.Query.Organizations == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Query.Organizations(childComplexity), true
|
|
|
|
|
|
|
|
case "Query.projects":
|
|
|
|
if e.complexity.Query.Projects == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
args, err := ec.field_Query_projects_args(context.TODO(), rawArgs)
|
|
|
|
if err != nil {
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Query.Projects(childComplexity, args["input"].(*ProjectsFilter)), true
|
|
|
|
|
|
|
|
case "Query.taskGroups":
|
|
|
|
if e.complexity.Query.TaskGroups == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Query.TaskGroups(childComplexity), true
|
|
|
|
|
|
|
|
case "Query.teams":
|
|
|
|
if e.complexity.Query.Teams == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Query.Teams(childComplexity), true
|
|
|
|
|
|
|
|
case "Query.users":
|
|
|
|
if e.complexity.Query.Users == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Query.Users(childComplexity), true
|
|
|
|
|
|
|
|
case "RefreshToken.createdAt":
|
|
|
|
if e.complexity.RefreshToken.CreatedAt == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.RefreshToken.CreatedAt(childComplexity), true
|
|
|
|
|
|
|
|
case "RefreshToken.expiresAt":
|
|
|
|
if e.complexity.RefreshToken.ExpiresAt == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.RefreshToken.ExpiresAt(childComplexity), true
|
|
|
|
|
|
|
|
case "RefreshToken.tokenId":
|
|
|
|
if e.complexity.RefreshToken.TokenID == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.RefreshToken.TokenID(childComplexity), true
|
|
|
|
|
|
|
|
case "RefreshToken.userId":
|
|
|
|
if e.complexity.RefreshToken.UserID == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.RefreshToken.UserID(childComplexity), true
|
|
|
|
|
|
|
|
case "Task.createdAt":
|
|
|
|
if e.complexity.Task.CreatedAt == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Task.CreatedAt(childComplexity), true
|
|
|
|
|
|
|
|
case "Task.name":
|
|
|
|
if e.complexity.Task.Name == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Task.Name(childComplexity), true
|
|
|
|
|
|
|
|
case "Task.position":
|
|
|
|
if e.complexity.Task.Position == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Task.Position(childComplexity), true
|
|
|
|
|
2020-04-11 04:22:22 +02:00
|
|
|
case "Task.taskGroup":
|
|
|
|
if e.complexity.Task.TaskGroup == nil {
|
2020-04-10 04:40:22 +02:00
|
|
|
break
|
|
|
|
}
|
|
|
|
|
2020-04-11 04:22:22 +02:00
|
|
|
return e.complexity.Task.TaskGroup(childComplexity), true
|
2020-04-10 04:40:22 +02:00
|
|
|
|
|
|
|
case "Task.taskID":
|
|
|
|
if e.complexity.Task.TaskID == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Task.TaskID(childComplexity), true
|
|
|
|
|
|
|
|
case "TaskGroup.createdAt":
|
|
|
|
if e.complexity.TaskGroup.CreatedAt == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.TaskGroup.CreatedAt(childComplexity), true
|
|
|
|
|
|
|
|
case "TaskGroup.name":
|
|
|
|
if e.complexity.TaskGroup.Name == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.TaskGroup.Name(childComplexity), true
|
|
|
|
|
|
|
|
case "TaskGroup.position":
|
|
|
|
if e.complexity.TaskGroup.Position == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.TaskGroup.Position(childComplexity), true
|
|
|
|
|
|
|
|
case "TaskGroup.projectID":
|
|
|
|
if e.complexity.TaskGroup.ProjectID == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.TaskGroup.ProjectID(childComplexity), true
|
|
|
|
|
|
|
|
case "TaskGroup.taskGroupID":
|
|
|
|
if e.complexity.TaskGroup.TaskGroupID == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.TaskGroup.TaskGroupID(childComplexity), true
|
|
|
|
|
|
|
|
case "TaskGroup.tasks":
|
|
|
|
if e.complexity.TaskGroup.Tasks == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.TaskGroup.Tasks(childComplexity), true
|
|
|
|
|
|
|
|
case "Team.createdAt":
|
|
|
|
if e.complexity.Team.CreatedAt == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Team.CreatedAt(childComplexity), true
|
|
|
|
|
|
|
|
case "Team.name":
|
|
|
|
if e.complexity.Team.Name == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Team.Name(childComplexity), true
|
|
|
|
|
|
|
|
case "Team.projects":
|
|
|
|
if e.complexity.Team.Projects == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Team.Projects(childComplexity), true
|
|
|
|
|
|
|
|
case "Team.teamID":
|
|
|
|
if e.complexity.Team.TeamID == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.Team.TeamID(childComplexity), true
|
|
|
|
|
|
|
|
case "UserAccount.createdAt":
|
|
|
|
if e.complexity.UserAccount.CreatedAt == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.UserAccount.CreatedAt(childComplexity), true
|
|
|
|
|
|
|
|
case "UserAccount.displayName":
|
|
|
|
if e.complexity.UserAccount.DisplayName == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.UserAccount.DisplayName(childComplexity), true
|
|
|
|
|
|
|
|
case "UserAccount.email":
|
|
|
|
if e.complexity.UserAccount.Email == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.UserAccount.Email(childComplexity), true
|
|
|
|
|
|
|
|
case "UserAccount.userID":
|
|
|
|
if e.complexity.UserAccount.UserID == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.UserAccount.UserID(childComplexity), true
|
|
|
|
|
|
|
|
case "UserAccount.username":
|
|
|
|
if e.complexity.UserAccount.Username == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.complexity.UserAccount.Username(childComplexity), true
|
|
|
|
|
|
|
|
}
|
|
|
|
return 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
|
|
|
|
rc := graphql.GetOperationContext(ctx)
|
|
|
|
ec := executionContext{rc, e}
|
|
|
|
first := true
|
|
|
|
|
|
|
|
switch rc.Operation.Operation {
|
|
|
|
case ast.Query:
|
|
|
|
return func(ctx context.Context) *graphql.Response {
|
|
|
|
if !first {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
first = false
|
|
|
|
data := ec._Query(ctx, rc.Operation.SelectionSet)
|
|
|
|
var buf bytes.Buffer
|
|
|
|
data.MarshalGQL(&buf)
|
|
|
|
|
|
|
|
return &graphql.Response{
|
|
|
|
Data: buf.Bytes(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
case ast.Mutation:
|
|
|
|
return func(ctx context.Context) *graphql.Response {
|
|
|
|
if !first {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
first = false
|
|
|
|
data := ec._Mutation(ctx, rc.Operation.SelectionSet)
|
|
|
|
var buf bytes.Buffer
|
|
|
|
data.MarshalGQL(&buf)
|
|
|
|
|
|
|
|
return &graphql.Response{
|
|
|
|
Data: buf.Bytes(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type executionContext struct {
|
|
|
|
*graphql.OperationContext
|
|
|
|
*executableSchema
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
|
|
|
|
if ec.DisableIntrospection {
|
|
|
|
return nil, errors.New("introspection disabled")
|
|
|
|
}
|
|
|
|
return introspection.WrapSchema(parsedSchema), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
|
|
|
|
if ec.DisableIntrospection {
|
|
|
|
return nil, errors.New("introspection disabled")
|
|
|
|
}
|
|
|
|
return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
var sources = []*ast.Source{
|
|
|
|
&ast.Source{Name: "graph/schema.graphqls", Input: `scalar Time
|
|
|
|
|
|
|
|
scalar UUID
|
|
|
|
|
|
|
|
type RefreshToken {
|
|
|
|
tokenId: ID!
|
|
|
|
userId: UUID!
|
|
|
|
expiresAt: Time!
|
|
|
|
createdAt: Time!
|
|
|
|
}
|
|
|
|
|
|
|
|
type UserAccount {
|
|
|
|
userID: ID!
|
|
|
|
email: String!
|
|
|
|
createdAt: Time!
|
|
|
|
displayName: String!
|
|
|
|
username: String!
|
|
|
|
}
|
|
|
|
|
|
|
|
type Organization {
|
|
|
|
organizationID: ID!
|
|
|
|
createdAt: Time!
|
|
|
|
name: String!
|
|
|
|
teams: [Team!]!
|
|
|
|
}
|
|
|
|
|
|
|
|
type Team {
|
|
|
|
teamID: ID!
|
|
|
|
createdAt: Time!
|
|
|
|
name: String!
|
|
|
|
projects: [Project!]!
|
|
|
|
}
|
|
|
|
|
|
|
|
type Project {
|
|
|
|
projectID: ID!
|
|
|
|
teamID: String!
|
|
|
|
createdAt: Time!
|
|
|
|
name: String!
|
|
|
|
taskGroups: [TaskGroup!]!
|
|
|
|
}
|
|
|
|
|
|
|
|
type TaskGroup {
|
|
|
|
taskGroupID: ID!
|
|
|
|
projectID: String!
|
|
|
|
createdAt: Time!
|
|
|
|
name: String!
|
|
|
|
position: Float!
|
|
|
|
tasks: [Task!]!
|
|
|
|
}
|
|
|
|
|
|
|
|
type Task {
|
|
|
|
taskID: ID!
|
2020-04-11 04:22:22 +02:00
|
|
|
taskGroup: TaskGroup!
|
2020-04-10 04:40:22 +02:00
|
|
|
createdAt: Time!
|
|
|
|
name: String!
|
|
|
|
position: Float!
|
|
|
|
}
|
|
|
|
|
|
|
|
input ProjectsFilter {
|
|
|
|
teamID: String
|
|
|
|
}
|
|
|
|
|
|
|
|
input FindUser {
|
|
|
|
userId: String!
|
|
|
|
}
|
|
|
|
|
|
|
|
input FindProject {
|
|
|
|
projectId: String!
|
|
|
|
}
|
|
|
|
|
|
|
|
type Query {
|
|
|
|
organizations: [Organization!]!
|
|
|
|
users: [UserAccount!]!
|
|
|
|
findUser(input: FindUser!): UserAccount!
|
|
|
|
findProject(input: FindProject!): Project!
|
|
|
|
teams: [Team!]!
|
|
|
|
projects(input: ProjectsFilter): [Project!]!
|
|
|
|
taskGroups: [TaskGroup!]!
|
|
|
|
}
|
|
|
|
|
|
|
|
input NewRefreshToken {
|
|
|
|
userId: String!
|
|
|
|
}
|
|
|
|
|
|
|
|
input NewUserAccount {
|
|
|
|
username: String!
|
|
|
|
email: String!
|
|
|
|
displayName: String!
|
|
|
|
password: String!
|
|
|
|
}
|
|
|
|
|
|
|
|
input NewTeam {
|
|
|
|
name: String!
|
|
|
|
organizationID: String!
|
|
|
|
}
|
|
|
|
|
|
|
|
input NewProject {
|
|
|
|
teamID: String!
|
|
|
|
name: String!
|
|
|
|
}
|
|
|
|
|
|
|
|
input NewTaskGroup {
|
|
|
|
projectID: String!
|
|
|
|
name: String!
|
|
|
|
position: Float!
|
|
|
|
}
|
|
|
|
|
|
|
|
input NewOrganization {
|
|
|
|
name: String!
|
|
|
|
}
|
|
|
|
|
|
|
|
input LogoutUser {
|
|
|
|
userID: String!
|
|
|
|
}
|
|
|
|
input NewTask {
|
|
|
|
taskGroupID: String!
|
|
|
|
name: String!
|
|
|
|
position: Float!
|
|
|
|
}
|
|
|
|
input NewTaskLocation {
|
|
|
|
taskID: String!
|
|
|
|
taskGroupID: String!
|
|
|
|
position: Float!
|
|
|
|
}
|
|
|
|
|
|
|
|
input DeleteTaskInput {
|
|
|
|
taskID: String!
|
|
|
|
}
|
|
|
|
|
|
|
|
type DeleteTaskPayload {
|
|
|
|
taskID: String!
|
|
|
|
}
|
|
|
|
|
|
|
|
input UpdateTaskName {
|
|
|
|
taskID: String!
|
|
|
|
name: String!
|
|
|
|
}
|
|
|
|
|
|
|
|
type Mutation {
|
|
|
|
createRefreshToken(input: NewRefreshToken!): RefreshToken!
|
|
|
|
createUserAccount(input: NewUserAccount!): UserAccount!
|
|
|
|
createOrganization(input: NewOrganization!): Organization!
|
|
|
|
createTeam(input: NewTeam!): Team!
|
|
|
|
createProject(input: NewProject!): Project!
|
|
|
|
createTaskGroup(input: NewTaskGroup!): TaskGroup!
|
|
|
|
createTask(input: NewTask!): Task!
|
|
|
|
updateTaskLocation(input: NewTaskLocation!): Task!
|
|
|
|
logoutUser(input: LogoutUser!): Boolean!
|
|
|
|
updateTaskName(input: UpdateTaskName!): Task!
|
|
|
|
deleteTask(input: DeleteTaskInput!): DeleteTaskPayload!
|
|
|
|
}
|
|
|
|
`, BuiltIn: false},
|
|
|
|
}
|
|
|
|
var parsedSchema = gqlparser.MustLoadSchema(sources...)
|
|
|
|
|
|
|
|
// endregion ************************** generated!.gotpl **************************
|
|
|
|
|
|
|
|
// region ***************************** args.gotpl *****************************
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Mutation_createOrganization_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 NewOrganization
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
arg0, err = ec.unmarshalNNewOrganization2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐNewOrganization(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Mutation_createProject_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 NewProject
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
arg0, err = ec.unmarshalNNewProject2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐNewProject(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Mutation_createRefreshToken_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 NewRefreshToken
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
arg0, err = ec.unmarshalNNewRefreshToken2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐNewRefreshToken(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Mutation_createTaskGroup_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 NewTaskGroup
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
arg0, err = ec.unmarshalNNewTaskGroup2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐNewTaskGroup(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Mutation_createTask_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 NewTask
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
arg0, err = ec.unmarshalNNewTask2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐNewTask(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Mutation_createTeam_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 NewTeam
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
arg0, err = ec.unmarshalNNewTeam2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐNewTeam(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Mutation_createUserAccount_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 NewUserAccount
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
arg0, err = ec.unmarshalNNewUserAccount2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐNewUserAccount(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Mutation_deleteTask_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 DeleteTaskInput
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
arg0, err = ec.unmarshalNDeleteTaskInput2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐDeleteTaskInput(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Mutation_logoutUser_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 LogoutUser
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
arg0, err = ec.unmarshalNLogoutUser2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐLogoutUser(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Mutation_updateTaskLocation_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 NewTaskLocation
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
arg0, err = ec.unmarshalNNewTaskLocation2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐNewTaskLocation(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Mutation_updateTaskName_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 UpdateTaskName
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
arg0, err = ec.unmarshalNUpdateTaskName2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐUpdateTaskName(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Query___type_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["name"]; ok {
|
|
|
|
arg0, err = ec.unmarshalNString2string(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["name"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Query_findProject_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 FindProject
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
arg0, err = ec.unmarshalNFindProject2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐFindProject(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Query_findUser_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 FindUser
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
arg0, err = ec.unmarshalNFindUser2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐFindUser(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field_Query_projects_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 *ProjectsFilter
|
|
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
|
|
arg0, err = ec.unmarshalOProjectsFilter2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐProjectsFilter(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["input"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 bool
|
|
|
|
if tmp, ok := rawArgs["includeDeprecated"]; ok {
|
|
|
|
arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["includeDeprecated"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
var err error
|
|
|
|
args := map[string]interface{}{}
|
|
|
|
var arg0 bool
|
|
|
|
if tmp, ok := rawArgs["includeDeprecated"]; ok {
|
|
|
|
arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
args["includeDeprecated"] = arg0
|
|
|
|
return args, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// endregion ***************************** args.gotpl *****************************
|
|
|
|
|
|
|
|
// region ************************** directives.gotpl **************************
|
|
|
|
|
|
|
|
// endregion ************************** directives.gotpl **************************
|
|
|
|
|
|
|
|
// region **************************** field.gotpl *****************************
|
|
|
|
|
|
|
|
func (ec *executionContext) _DeleteTaskPayload_taskID(ctx context.Context, field graphql.CollectedField, obj *DeleteTaskPayload) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "DeleteTaskPayload",
|
|
|
|
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.TaskID, 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.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Mutation_createRefreshToken(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: "Mutation",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Mutation_createRefreshToken_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.Mutation().CreateRefreshToken(rctx, args["input"].(NewRefreshToken))
|
|
|
|
})
|
|
|
|
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.(*pg.RefreshToken)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNRefreshToken2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐRefreshToken(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Mutation_createUserAccount(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: "Mutation",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Mutation_createUserAccount_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.Mutation().CreateUserAccount(rctx, args["input"].(NewUserAccount))
|
|
|
|
})
|
|
|
|
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.(*pg.UserAccount)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNUserAccount2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐUserAccount(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Mutation_createOrganization(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: "Mutation",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Mutation_createOrganization_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.Mutation().CreateOrganization(rctx, args["input"].(NewOrganization))
|
|
|
|
})
|
|
|
|
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.(*pg.Organization)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNOrganization2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐOrganization(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Mutation_createTeam(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: "Mutation",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Mutation_createTeam_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.Mutation().CreateTeam(rctx, args["input"].(NewTeam))
|
|
|
|
})
|
|
|
|
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.(*pg.Team)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNTeam2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTeam(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Mutation_createProject(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: "Mutation",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Mutation_createProject_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.Mutation().CreateProject(rctx, args["input"].(NewProject))
|
|
|
|
})
|
|
|
|
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.(*pg.Project)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNProject2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐProject(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Mutation_createTaskGroup(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: "Mutation",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Mutation_createTaskGroup_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.Mutation().CreateTaskGroup(rctx, args["input"].(NewTaskGroup))
|
|
|
|
})
|
|
|
|
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.(*pg.TaskGroup)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNTaskGroup2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTaskGroup(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Mutation_createTask(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: "Mutation",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Mutation_createTask_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.Mutation().CreateTask(rctx, args["input"].(NewTask))
|
|
|
|
})
|
|
|
|
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.(*pg.Task)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNTask2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTask(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Mutation_updateTaskLocation(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: "Mutation",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Mutation_updateTaskLocation_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.Mutation().UpdateTaskLocation(rctx, args["input"].(NewTaskLocation))
|
|
|
|
})
|
|
|
|
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.(*pg.Task)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNTask2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTask(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Mutation_logoutUser(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: "Mutation",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Mutation_logoutUser_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.Mutation().LogoutUser(rctx, args["input"].(LogoutUser))
|
|
|
|
})
|
|
|
|
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.(bool)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Mutation_updateTaskName(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: "Mutation",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Mutation_updateTaskName_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.Mutation().UpdateTaskName(rctx, args["input"].(UpdateTaskName))
|
|
|
|
})
|
|
|
|
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.(*pg.Task)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNTask2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTask(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Mutation_deleteTask(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: "Mutation",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field_Mutation_deleteTask_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.Mutation().DeleteTask(rctx, args["input"].(DeleteTaskInput))
|
|
|
|
})
|
|
|
|
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.(*DeleteTaskPayload)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNDeleteTaskPayload2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐDeleteTaskPayload(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Organization_organizationID(ctx context.Context, field graphql.CollectedField, obj *pg.Organization) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Organization",
|
|
|
|
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.OrganizationID, 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.(uuid.UUID)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNID2githubᚗcomᚋgoogleᚋuuidᚐUUID(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Organization_createdAt(ctx context.Context, field graphql.CollectedField, obj *pg.Organization) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Organization",
|
|
|
|
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) _Organization_name(ctx context.Context, field graphql.CollectedField, obj *pg.Organization) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Organization",
|
|
|
|
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.Name, 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.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Organization_teams(ctx context.Context, field graphql.CollectedField, obj *pg.Organization) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Organization",
|
|
|
|
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.Organization().Teams(rctx, obj)
|
|
|
|
})
|
|
|
|
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.([]pg.Team)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNTeam2ᚕgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTeamᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Project_projectID(ctx context.Context, field graphql.CollectedField, obj *pg.Project) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Project",
|
|
|
|
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.ProjectID, 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.(uuid.UUID)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNID2githubᚗcomᚋgoogleᚋuuidᚐUUID(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Project_teamID(ctx context.Context, field graphql.CollectedField, obj *pg.Project) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Project",
|
|
|
|
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.Project().TeamID(rctx, obj)
|
|
|
|
})
|
|
|
|
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.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Project_createdAt(ctx context.Context, field graphql.CollectedField, obj *pg.Project) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Project",
|
|
|
|
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) _Project_name(ctx context.Context, field graphql.CollectedField, obj *pg.Project) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Project",
|
|
|
|
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.Name, 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.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Project_taskGroups(ctx context.Context, field graphql.CollectedField, obj *pg.Project) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Project",
|
|
|
|
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.Project().TaskGroups(rctx, obj)
|
|
|
|
})
|
|
|
|
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.([]pg.TaskGroup)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNTaskGroup2ᚕgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTaskGroupᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Query_organizations(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)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return ec.resolvers.Query().Organizations(rctx)
|
|
|
|
})
|
|
|
|
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.([]pg.Organization)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNOrganization2ᚕgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐOrganizationᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Query_users(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)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return ec.resolvers.Query().Users(rctx)
|
|
|
|
})
|
|
|
|
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.([]pg.UserAccount)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNUserAccount2ᚕgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐUserAccountᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Query_findUser(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_findUser_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().FindUser(rctx, args["input"].(FindUser))
|
|
|
|
})
|
|
|
|
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.(*pg.UserAccount)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNUserAccount2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐUserAccount(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Query_findProject(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_findProject_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().FindProject(rctx, args["input"].(FindProject))
|
|
|
|
})
|
|
|
|
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.(*pg.Project)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNProject2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐProject(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Query_teams(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)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return ec.resolvers.Query().Teams(rctx)
|
|
|
|
})
|
|
|
|
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.([]pg.Team)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNTeam2ᚕgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTeamᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Query_projects(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_projects_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().Projects(rctx, args["input"].(*ProjectsFilter))
|
|
|
|
})
|
|
|
|
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.([]pg.Project)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNProject2ᚕgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐProjectᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Query_taskGroups(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)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return ec.resolvers.Query().TaskGroups(rctx)
|
|
|
|
})
|
|
|
|
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.([]pg.TaskGroup)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNTaskGroup2ᚕgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTaskGroupᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Query___type(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___type_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.introspectType(args["name"].(string))
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Query___schema(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)
|
|
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
|
|
ctx = rctx // use context from middleware stack in children
|
|
|
|
return ec.introspectSchema()
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*introspection.Schema)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _RefreshToken_tokenId(ctx context.Context, field graphql.CollectedField, obj *pg.RefreshToken) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "RefreshToken",
|
|
|
|
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.TokenID, 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.(uuid.UUID)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNID2githubᚗcomᚋgoogleᚋuuidᚐUUID(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _RefreshToken_userId(ctx context.Context, field graphql.CollectedField, obj *pg.RefreshToken) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "RefreshToken",
|
|
|
|
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.UserID, 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.(uuid.UUID)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNUUID2githubᚗcomᚋgoogleᚋuuidᚐUUID(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _RefreshToken_expiresAt(ctx context.Context, field graphql.CollectedField, obj *pg.RefreshToken) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "RefreshToken",
|
|
|
|
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.ExpiresAt, 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) _RefreshToken_createdAt(ctx context.Context, field graphql.CollectedField, obj *pg.RefreshToken) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "RefreshToken",
|
|
|
|
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) _Task_taskID(ctx context.Context, field graphql.CollectedField, obj *pg.Task) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Task",
|
|
|
|
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.TaskID, 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.(uuid.UUID)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNID2githubᚗcomᚋgoogleᚋuuidᚐUUID(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
2020-04-11 04:22:22 +02:00
|
|
|
func (ec *executionContext) _Task_taskGroup(ctx context.Context, field graphql.CollectedField, obj *pg.Task) (ret graphql.Marshaler) {
|
2020-04-10 04:40:22 +02:00
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Task",
|
|
|
|
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
|
2020-04-11 04:22:22 +02:00
|
|
|
return ec.resolvers.Task().TaskGroup(rctx, obj)
|
2020-04-10 04:40:22 +02:00
|
|
|
})
|
|
|
|
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
|
|
|
|
}
|
2020-04-11 04:22:22 +02:00
|
|
|
res := resTmp.(*pg.TaskGroup)
|
2020-04-10 04:40:22 +02:00
|
|
|
fc.Result = res
|
2020-04-11 04:22:22 +02:00
|
|
|
return ec.marshalNTaskGroup2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTaskGroup(ctx, field.Selections, res)
|
2020-04-10 04:40:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Task_createdAt(ctx context.Context, field graphql.CollectedField, obj *pg.Task) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Task",
|
|
|
|
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) _Task_name(ctx context.Context, field graphql.CollectedField, obj *pg.Task) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Task",
|
|
|
|
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.Name, 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.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Task_position(ctx context.Context, field graphql.CollectedField, obj *pg.Task) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Task",
|
|
|
|
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.Position, 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.(float64)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNFloat2float64(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _TaskGroup_taskGroupID(ctx context.Context, field graphql.CollectedField, obj *pg.TaskGroup) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "TaskGroup",
|
|
|
|
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.TaskGroupID, 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.(uuid.UUID)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNID2githubᚗcomᚋgoogleᚋuuidᚐUUID(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _TaskGroup_projectID(ctx context.Context, field graphql.CollectedField, obj *pg.TaskGroup) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "TaskGroup",
|
|
|
|
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.TaskGroup().ProjectID(rctx, obj)
|
|
|
|
})
|
|
|
|
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.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _TaskGroup_createdAt(ctx context.Context, field graphql.CollectedField, obj *pg.TaskGroup) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "TaskGroup",
|
|
|
|
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) _TaskGroup_name(ctx context.Context, field graphql.CollectedField, obj *pg.TaskGroup) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "TaskGroup",
|
|
|
|
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.Name, 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.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _TaskGroup_position(ctx context.Context, field graphql.CollectedField, obj *pg.TaskGroup) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "TaskGroup",
|
|
|
|
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.Position, 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.(float64)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNFloat2float64(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _TaskGroup_tasks(ctx context.Context, field graphql.CollectedField, obj *pg.TaskGroup) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "TaskGroup",
|
|
|
|
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.TaskGroup().Tasks(rctx, obj)
|
|
|
|
})
|
|
|
|
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.([]pg.Task)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNTask2ᚕgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTaskᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Team_teamID(ctx context.Context, field graphql.CollectedField, obj *pg.Team) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Team",
|
|
|
|
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.TeamID, 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.(uuid.UUID)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNID2githubᚗcomᚋgoogleᚋuuidᚐUUID(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Team_createdAt(ctx context.Context, field graphql.CollectedField, obj *pg.Team) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Team",
|
|
|
|
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) _Team_name(ctx context.Context, field graphql.CollectedField, obj *pg.Team) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Team",
|
|
|
|
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.Name, 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.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Team_projects(ctx context.Context, field graphql.CollectedField, obj *pg.Team) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "Team",
|
|
|
|
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.Team().Projects(rctx, obj)
|
|
|
|
})
|
|
|
|
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.([]pg.Project)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNProject2ᚕgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐProjectᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _UserAccount_userID(ctx context.Context, field graphql.CollectedField, obj *pg.UserAccount) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "UserAccount",
|
|
|
|
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.UserID, 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.(uuid.UUID)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNID2githubᚗcomᚋgoogleᚋuuidᚐUUID(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _UserAccount_email(ctx context.Context, field graphql.CollectedField, obj *pg.UserAccount) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "UserAccount",
|
|
|
|
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.Email, 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.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _UserAccount_createdAt(ctx context.Context, field graphql.CollectedField, obj *pg.UserAccount) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "UserAccount",
|
|
|
|
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) _UserAccount_displayName(ctx context.Context, field graphql.CollectedField, obj *pg.UserAccount) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "UserAccount",
|
|
|
|
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.DisplayName, 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.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) _UserAccount_username(ctx context.Context, field graphql.CollectedField, obj *pg.UserAccount) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "UserAccount",
|
|
|
|
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.Username, 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.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Directive",
|
|
|
|
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.Name, 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.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Directive",
|
|
|
|
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.Description, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Directive",
|
|
|
|
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.Locations, 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.([]string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Directive",
|
|
|
|
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.Args, 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.([]introspection.InputValue)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__EnumValue",
|
|
|
|
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.Name, 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.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__EnumValue",
|
|
|
|
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.Description, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__EnumValue",
|
|
|
|
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 obj.IsDeprecated(), 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.(bool)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__EnumValue",
|
|
|
|
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 obj.DeprecationReason(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Field",
|
|
|
|
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.Name, 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.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Field",
|
|
|
|
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.Description, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Field",
|
|
|
|
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.Args, 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.([]introspection.InputValue)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Field",
|
|
|
|
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.Type, 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.(*introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Field",
|
|
|
|
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 obj.IsDeprecated(), 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.(bool)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Field",
|
|
|
|
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 obj.DeprecationReason(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__InputValue",
|
|
|
|
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.Name, 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.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__InputValue",
|
|
|
|
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.Description, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__InputValue",
|
|
|
|
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.Type, 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.(*introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__InputValue",
|
|
|
|
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.DefaultValue, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Schema",
|
|
|
|
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 obj.Types(), 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.([]introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Schema",
|
|
|
|
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 obj.QueryType(), 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.(*introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Schema",
|
|
|
|
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 obj.MutationType(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Schema",
|
|
|
|
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 obj.SubscriptionType(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Schema",
|
|
|
|
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 obj.Directives(), 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.([]introspection.Directive)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
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 obj.Kind(), 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.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
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 obj.Name(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
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 obj.Description(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(string)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field___Type_fields_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 obj.Fields(args["includeDeprecated"].(bool)), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]introspection.Field)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
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 obj.Interfaces(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
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 obj.PossibleTypes(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
Field: field,
|
|
|
|
Args: nil,
|
|
|
|
IsMethod: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, fc)
|
|
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
|
|
args, err := ec.field___Type_enumValues_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 obj.EnumValues(args["includeDeprecated"].(bool)), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]introspection.EnumValue)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
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 obj.InputFields(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.([]introspection.InputValue)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
ret = graphql.Null
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
fc := &graphql.FieldContext{
|
|
|
|
Object: "__Type",
|
|
|
|
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 obj.OfType(), nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ec.Error(ctx, err)
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
if resTmp == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
res := resTmp.(*introspection.Type)
|
|
|
|
fc.Result = res
|
|
|
|
return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
|
|
}
|
|
|
|
|
|
|
|
// endregion **************************** field.gotpl *****************************
|
|
|
|
|
|
|
|
// region **************************** input.gotpl *****************************
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputDeleteTaskInput(ctx context.Context, obj interface{}) (DeleteTaskInput, error) {
|
|
|
|
var it DeleteTaskInput
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "taskID":
|
|
|
|
var err error
|
|
|
|
it.TaskID, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputFindProject(ctx context.Context, obj interface{}) (FindProject, error) {
|
|
|
|
var it FindProject
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "projectId":
|
|
|
|
var err error
|
|
|
|
it.ProjectID, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputFindUser(ctx context.Context, obj interface{}) (FindUser, error) {
|
|
|
|
var it FindUser
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "userId":
|
|
|
|
var err error
|
|
|
|
it.UserID, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputLogoutUser(ctx context.Context, obj interface{}) (LogoutUser, error) {
|
|
|
|
var it LogoutUser
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "userID":
|
|
|
|
var err error
|
|
|
|
it.UserID, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputNewOrganization(ctx context.Context, obj interface{}) (NewOrganization, error) {
|
|
|
|
var it NewOrganization
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "name":
|
|
|
|
var err error
|
|
|
|
it.Name, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputNewProject(ctx context.Context, obj interface{}) (NewProject, error) {
|
|
|
|
var it NewProject
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "teamID":
|
|
|
|
var err error
|
|
|
|
it.TeamID, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
case "name":
|
|
|
|
var err error
|
|
|
|
it.Name, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputNewRefreshToken(ctx context.Context, obj interface{}) (NewRefreshToken, error) {
|
|
|
|
var it NewRefreshToken
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "userId":
|
|
|
|
var err error
|
|
|
|
it.UserID, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputNewTask(ctx context.Context, obj interface{}) (NewTask, error) {
|
|
|
|
var it NewTask
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "taskGroupID":
|
|
|
|
var err error
|
|
|
|
it.TaskGroupID, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
case "name":
|
|
|
|
var err error
|
|
|
|
it.Name, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
case "position":
|
|
|
|
var err error
|
|
|
|
it.Position, err = ec.unmarshalNFloat2float64(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputNewTaskGroup(ctx context.Context, obj interface{}) (NewTaskGroup, error) {
|
|
|
|
var it NewTaskGroup
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "projectID":
|
|
|
|
var err error
|
|
|
|
it.ProjectID, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
case "name":
|
|
|
|
var err error
|
|
|
|
it.Name, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
case "position":
|
|
|
|
var err error
|
|
|
|
it.Position, err = ec.unmarshalNFloat2float64(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputNewTaskLocation(ctx context.Context, obj interface{}) (NewTaskLocation, error) {
|
|
|
|
var it NewTaskLocation
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "taskID":
|
|
|
|
var err error
|
|
|
|
it.TaskID, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
case "taskGroupID":
|
|
|
|
var err error
|
|
|
|
it.TaskGroupID, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
case "position":
|
|
|
|
var err error
|
|
|
|
it.Position, err = ec.unmarshalNFloat2float64(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputNewTeam(ctx context.Context, obj interface{}) (NewTeam, error) {
|
|
|
|
var it NewTeam
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "name":
|
|
|
|
var err error
|
|
|
|
it.Name, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
case "organizationID":
|
|
|
|
var err error
|
|
|
|
it.OrganizationID, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputNewUserAccount(ctx context.Context, obj interface{}) (NewUserAccount, error) {
|
|
|
|
var it NewUserAccount
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "username":
|
|
|
|
var err error
|
|
|
|
it.Username, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
case "email":
|
|
|
|
var err error
|
|
|
|
it.Email, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
case "displayName":
|
|
|
|
var err error
|
|
|
|
it.DisplayName, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
case "password":
|
|
|
|
var err error
|
|
|
|
it.Password, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputProjectsFilter(ctx context.Context, obj interface{}) (ProjectsFilter, error) {
|
|
|
|
var it ProjectsFilter
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "teamID":
|
|
|
|
var err error
|
|
|
|
it.TeamID, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalInputUpdateTaskName(ctx context.Context, obj interface{}) (UpdateTaskName, error) {
|
|
|
|
var it UpdateTaskName
|
|
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
|
|
|
|
for k, v := range asMap {
|
|
|
|
switch k {
|
|
|
|
case "taskID":
|
|
|
|
var err error
|
|
|
|
it.TaskID, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
case "name":
|
|
|
|
var err error
|
|
|
|
it.Name, err = ec.unmarshalNString2string(ctx, v)
|
|
|
|
if err != nil {
|
|
|
|
return it, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return it, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// endregion **************************** input.gotpl *****************************
|
|
|
|
|
|
|
|
// region ************************** interface.gotpl ***************************
|
|
|
|
|
|
|
|
// endregion ************************** interface.gotpl ***************************
|
|
|
|
|
|
|
|
// region **************************** object.gotpl ****************************
|
|
|
|
|
|
|
|
var deleteTaskPayloadImplementors = []string{"DeleteTaskPayload"}
|
|
|
|
|
|
|
|
func (ec *executionContext) _DeleteTaskPayload(ctx context.Context, sel ast.SelectionSet, obj *DeleteTaskPayload) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, deleteTaskPayloadImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("DeleteTaskPayload")
|
|
|
|
case "taskID":
|
|
|
|
out.Values[i] = ec._DeleteTaskPayload_taskID(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var mutationImplementors = []string{"Mutation"}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
|
|
|
|
Object: "Mutation",
|
|
|
|
})
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("Mutation")
|
|
|
|
case "createRefreshToken":
|
|
|
|
out.Values[i] = ec._Mutation_createRefreshToken(ctx, field)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "createUserAccount":
|
|
|
|
out.Values[i] = ec._Mutation_createUserAccount(ctx, field)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "createOrganization":
|
|
|
|
out.Values[i] = ec._Mutation_createOrganization(ctx, field)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "createTeam":
|
|
|
|
out.Values[i] = ec._Mutation_createTeam(ctx, field)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "createProject":
|
|
|
|
out.Values[i] = ec._Mutation_createProject(ctx, field)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "createTaskGroup":
|
|
|
|
out.Values[i] = ec._Mutation_createTaskGroup(ctx, field)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "createTask":
|
|
|
|
out.Values[i] = ec._Mutation_createTask(ctx, field)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "updateTaskLocation":
|
|
|
|
out.Values[i] = ec._Mutation_updateTaskLocation(ctx, field)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "logoutUser":
|
|
|
|
out.Values[i] = ec._Mutation_logoutUser(ctx, field)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "updateTaskName":
|
|
|
|
out.Values[i] = ec._Mutation_updateTaskName(ctx, field)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "deleteTask":
|
|
|
|
out.Values[i] = ec._Mutation_deleteTask(ctx, field)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var organizationImplementors = []string{"Organization"}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Organization(ctx context.Context, sel ast.SelectionSet, obj *pg.Organization) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, organizationImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("Organization")
|
|
|
|
case "organizationID":
|
|
|
|
out.Values[i] = ec._Organization_organizationID(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
case "createdAt":
|
|
|
|
out.Values[i] = ec._Organization_createdAt(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
case "name":
|
|
|
|
out.Values[i] = ec._Organization_name(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
case "teams":
|
|
|
|
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._Organization_teams(ctx, field, obj)
|
|
|
|
if res == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var projectImplementors = []string{"Project"}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Project(ctx context.Context, sel ast.SelectionSet, obj *pg.Project) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, projectImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("Project")
|
|
|
|
case "projectID":
|
|
|
|
out.Values[i] = ec._Project_projectID(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
case "teamID":
|
|
|
|
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._Project_teamID(ctx, field, obj)
|
|
|
|
if res == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
case "createdAt":
|
|
|
|
out.Values[i] = ec._Project_createdAt(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
case "name":
|
|
|
|
out.Values[i] = ec._Project_name(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
case "taskGroups":
|
|
|
|
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._Project_taskGroups(ctx, field, obj)
|
|
|
|
if res == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var queryImplementors = []string{"Query"}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
|
|
|
|
|
|
|
|
ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
|
|
|
|
Object: "Query",
|
|
|
|
})
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("Query")
|
|
|
|
case "organizations":
|
|
|
|
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_organizations(ctx, field)
|
|
|
|
if res == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
case "users":
|
|
|
|
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_users(ctx, field)
|
|
|
|
if res == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
case "findUser":
|
|
|
|
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_findUser(ctx, field)
|
|
|
|
if res == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
case "findProject":
|
|
|
|
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_findProject(ctx, field)
|
|
|
|
if res == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
case "teams":
|
|
|
|
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_teams(ctx, field)
|
|
|
|
if res == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
case "projects":
|
|
|
|
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_projects(ctx, field)
|
|
|
|
if res == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
case "taskGroups":
|
|
|
|
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_taskGroups(ctx, field)
|
|
|
|
if res == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
case "__type":
|
|
|
|
out.Values[i] = ec._Query___type(ctx, field)
|
|
|
|
case "__schema":
|
|
|
|
out.Values[i] = ec._Query___schema(ctx, field)
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var refreshTokenImplementors = []string{"RefreshToken"}
|
|
|
|
|
|
|
|
func (ec *executionContext) _RefreshToken(ctx context.Context, sel ast.SelectionSet, obj *pg.RefreshToken) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, refreshTokenImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("RefreshToken")
|
|
|
|
case "tokenId":
|
|
|
|
out.Values[i] = ec._RefreshToken_tokenId(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "userId":
|
|
|
|
out.Values[i] = ec._RefreshToken_userId(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "expiresAt":
|
|
|
|
out.Values[i] = ec._RefreshToken_expiresAt(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "createdAt":
|
|
|
|
out.Values[i] = ec._RefreshToken_createdAt(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var taskImplementors = []string{"Task"}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Task(ctx context.Context, sel ast.SelectionSet, obj *pg.Task) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, taskImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("Task")
|
|
|
|
case "taskID":
|
|
|
|
out.Values[i] = ec._Task_taskID(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
2020-04-11 04:22:22 +02:00
|
|
|
case "taskGroup":
|
2020-04-10 04:40:22 +02:00
|
|
|
field := field
|
|
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
|
|
}
|
|
|
|
}()
|
2020-04-11 04:22:22 +02:00
|
|
|
res = ec._Task_taskGroup(ctx, field, obj)
|
2020-04-10 04:40:22 +02:00
|
|
|
if res == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
case "createdAt":
|
|
|
|
out.Values[i] = ec._Task_createdAt(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
case "name":
|
|
|
|
out.Values[i] = ec._Task_name(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
case "position":
|
|
|
|
out.Values[i] = ec._Task_position(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 taskGroupImplementors = []string{"TaskGroup"}
|
|
|
|
|
|
|
|
func (ec *executionContext) _TaskGroup(ctx context.Context, sel ast.SelectionSet, obj *pg.TaskGroup) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, taskGroupImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("TaskGroup")
|
|
|
|
case "taskGroupID":
|
|
|
|
out.Values[i] = ec._TaskGroup_taskGroupID(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
case "projectID":
|
|
|
|
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._TaskGroup_projectID(ctx, field, obj)
|
|
|
|
if res == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
case "createdAt":
|
|
|
|
out.Values[i] = ec._TaskGroup_createdAt(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
case "name":
|
|
|
|
out.Values[i] = ec._TaskGroup_name(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
case "position":
|
|
|
|
out.Values[i] = ec._TaskGroup_position(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
case "tasks":
|
|
|
|
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._TaskGroup_tasks(ctx, field, obj)
|
|
|
|
if res == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var teamImplementors = []string{"Team"}
|
|
|
|
|
|
|
|
func (ec *executionContext) _Team(ctx context.Context, sel ast.SelectionSet, obj *pg.Team) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, teamImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("Team")
|
|
|
|
case "teamID":
|
|
|
|
out.Values[i] = ec._Team_teamID(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
case "createdAt":
|
|
|
|
out.Values[i] = ec._Team_createdAt(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
case "name":
|
|
|
|
out.Values[i] = ec._Team_name(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
case "projects":
|
|
|
|
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._Team_projects(ctx, field, obj)
|
|
|
|
if res == graphql.Null {
|
|
|
|
atomic.AddUint32(&invalids, 1)
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
})
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var userAccountImplementors = []string{"UserAccount"}
|
|
|
|
|
|
|
|
func (ec *executionContext) _UserAccount(ctx context.Context, sel ast.SelectionSet, obj *pg.UserAccount) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, userAccountImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("UserAccount")
|
|
|
|
case "userID":
|
|
|
|
out.Values[i] = ec._UserAccount_userID(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "email":
|
|
|
|
out.Values[i] = ec._UserAccount_email(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "createdAt":
|
|
|
|
out.Values[i] = ec._UserAccount_createdAt(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "displayName":
|
|
|
|
out.Values[i] = ec._UserAccount_displayName(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "username":
|
|
|
|
out.Values[i] = ec._UserAccount_username(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var __DirectiveImplementors = []string{"__Directive"}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("__Directive")
|
|
|
|
case "name":
|
|
|
|
out.Values[i] = ec.___Directive_name(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "description":
|
|
|
|
out.Values[i] = ec.___Directive_description(ctx, field, obj)
|
|
|
|
case "locations":
|
|
|
|
out.Values[i] = ec.___Directive_locations(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "args":
|
|
|
|
out.Values[i] = ec.___Directive_args(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var __EnumValueImplementors = []string{"__EnumValue"}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("__EnumValue")
|
|
|
|
case "name":
|
|
|
|
out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "description":
|
|
|
|
out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
|
|
|
|
case "isDeprecated":
|
|
|
|
out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "deprecationReason":
|
|
|
|
out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var __FieldImplementors = []string{"__Field"}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("__Field")
|
|
|
|
case "name":
|
|
|
|
out.Values[i] = ec.___Field_name(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "description":
|
|
|
|
out.Values[i] = ec.___Field_description(ctx, field, obj)
|
|
|
|
case "args":
|
|
|
|
out.Values[i] = ec.___Field_args(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "type":
|
|
|
|
out.Values[i] = ec.___Field_type(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "isDeprecated":
|
|
|
|
out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "deprecationReason":
|
|
|
|
out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var __InputValueImplementors = []string{"__InputValue"}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("__InputValue")
|
|
|
|
case "name":
|
|
|
|
out.Values[i] = ec.___InputValue_name(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "description":
|
|
|
|
out.Values[i] = ec.___InputValue_description(ctx, field, obj)
|
|
|
|
case "type":
|
|
|
|
out.Values[i] = ec.___InputValue_type(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "defaultValue":
|
|
|
|
out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var __SchemaImplementors = []string{"__Schema"}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("__Schema")
|
|
|
|
case "types":
|
|
|
|
out.Values[i] = ec.___Schema_types(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "queryType":
|
|
|
|
out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "mutationType":
|
|
|
|
out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
|
|
|
|
case "subscriptionType":
|
|
|
|
out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
|
|
|
|
case "directives":
|
|
|
|
out.Values[i] = ec.___Schema_directives(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
var __TypeImplementors = []string{"__Type"}
|
|
|
|
|
|
|
|
func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
|
|
|
|
fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
|
|
|
|
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
|
|
var invalids uint32
|
|
|
|
for i, field := range fields {
|
|
|
|
switch field.Name {
|
|
|
|
case "__typename":
|
|
|
|
out.Values[i] = graphql.MarshalString("__Type")
|
|
|
|
case "kind":
|
|
|
|
out.Values[i] = ec.___Type_kind(ctx, field, obj)
|
|
|
|
if out.Values[i] == graphql.Null {
|
|
|
|
invalids++
|
|
|
|
}
|
|
|
|
case "name":
|
|
|
|
out.Values[i] = ec.___Type_name(ctx, field, obj)
|
|
|
|
case "description":
|
|
|
|
out.Values[i] = ec.___Type_description(ctx, field, obj)
|
|
|
|
case "fields":
|
|
|
|
out.Values[i] = ec.___Type_fields(ctx, field, obj)
|
|
|
|
case "interfaces":
|
|
|
|
out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
|
|
|
|
case "possibleTypes":
|
|
|
|
out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
|
|
|
|
case "enumValues":
|
|
|
|
out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
|
|
|
|
case "inputFields":
|
|
|
|
out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
|
|
|
|
case "ofType":
|
|
|
|
out.Values[i] = ec.___Type_ofType(ctx, field, obj)
|
|
|
|
default:
|
|
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out.Dispatch()
|
|
|
|
if invalids > 0 {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
|
|
|
|
// endregion **************************** object.gotpl ****************************
|
|
|
|
|
|
|
|
// region ***************************** type.gotpl *****************************
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
|
|
|
|
return graphql.UnmarshalBoolean(v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
|
|
|
|
res := graphql.MarshalBoolean(v)
|
|
|
|
if res == graphql.Null {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNDeleteTaskInput2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐDeleteTaskInput(ctx context.Context, v interface{}) (DeleteTaskInput, error) {
|
|
|
|
return ec.unmarshalInputDeleteTaskInput(ctx, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNDeleteTaskPayload2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐDeleteTaskPayload(ctx context.Context, sel ast.SelectionSet, v DeleteTaskPayload) graphql.Marshaler {
|
|
|
|
return ec._DeleteTaskPayload(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNDeleteTaskPayload2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐDeleteTaskPayload(ctx context.Context, sel ast.SelectionSet, v *DeleteTaskPayload) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec._DeleteTaskPayload(ctx, sel, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNFindProject2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐFindProject(ctx context.Context, v interface{}) (FindProject, error) {
|
|
|
|
return ec.unmarshalInputFindProject(ctx, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNFindUser2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐFindUser(ctx context.Context, v interface{}) (FindUser, error) {
|
|
|
|
return ec.unmarshalInputFindUser(ctx, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNFloat2float64(ctx context.Context, v interface{}) (float64, error) {
|
|
|
|
return graphql.UnmarshalFloat(v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNFloat2float64(ctx context.Context, sel ast.SelectionSet, v float64) graphql.Marshaler {
|
|
|
|
res := graphql.MarshalFloat(v)
|
|
|
|
if res == graphql.Null {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNID2githubᚗcomᚋgoogleᚋuuidᚐUUID(ctx context.Context, v interface{}) (uuid.UUID, error) {
|
|
|
|
return UnmarshalUUID(v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNID2githubᚗcomᚋgoogleᚋuuidᚐUUID(ctx context.Context, sel ast.SelectionSet, v uuid.UUID) graphql.Marshaler {
|
|
|
|
res := MarshalUUID(v)
|
|
|
|
if res == graphql.Null {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNLogoutUser2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐLogoutUser(ctx context.Context, v interface{}) (LogoutUser, error) {
|
|
|
|
return ec.unmarshalInputLogoutUser(ctx, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNNewOrganization2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐNewOrganization(ctx context.Context, v interface{}) (NewOrganization, error) {
|
|
|
|
return ec.unmarshalInputNewOrganization(ctx, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNNewProject2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐNewProject(ctx context.Context, v interface{}) (NewProject, error) {
|
|
|
|
return ec.unmarshalInputNewProject(ctx, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNNewRefreshToken2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐNewRefreshToken(ctx context.Context, v interface{}) (NewRefreshToken, error) {
|
|
|
|
return ec.unmarshalInputNewRefreshToken(ctx, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNNewTask2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐNewTask(ctx context.Context, v interface{}) (NewTask, error) {
|
|
|
|
return ec.unmarshalInputNewTask(ctx, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNNewTaskGroup2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐNewTaskGroup(ctx context.Context, v interface{}) (NewTaskGroup, error) {
|
|
|
|
return ec.unmarshalInputNewTaskGroup(ctx, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNNewTaskLocation2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐNewTaskLocation(ctx context.Context, v interface{}) (NewTaskLocation, error) {
|
|
|
|
return ec.unmarshalInputNewTaskLocation(ctx, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNNewTeam2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐNewTeam(ctx context.Context, v interface{}) (NewTeam, error) {
|
|
|
|
return ec.unmarshalInputNewTeam(ctx, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNNewUserAccount2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐNewUserAccount(ctx context.Context, v interface{}) (NewUserAccount, error) {
|
|
|
|
return ec.unmarshalInputNewUserAccount(ctx, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNOrganization2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐOrganization(ctx context.Context, sel ast.SelectionSet, v pg.Organization) graphql.Marshaler {
|
|
|
|
return ec._Organization(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNOrganization2ᚕgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐOrganizationᚄ(ctx context.Context, sel ast.SelectionSet, v []pg.Organization) graphql.Marshaler {
|
|
|
|
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.marshalNOrganization2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐOrganization(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNOrganization2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐOrganization(ctx context.Context, sel ast.SelectionSet, v *pg.Organization) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec._Organization(ctx, sel, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNProject2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐProject(ctx context.Context, sel ast.SelectionSet, v pg.Project) graphql.Marshaler {
|
|
|
|
return ec._Project(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNProject2ᚕgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐProjectᚄ(ctx context.Context, sel ast.SelectionSet, v []pg.Project) graphql.Marshaler {
|
|
|
|
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.marshalNProject2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐProject(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNProject2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐProject(ctx context.Context, sel ast.SelectionSet, v *pg.Project) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec._Project(ctx, sel, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNRefreshToken2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐRefreshToken(ctx context.Context, sel ast.SelectionSet, v pg.RefreshToken) graphql.Marshaler {
|
|
|
|
return ec._RefreshToken(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNRefreshToken2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐRefreshToken(ctx context.Context, sel ast.SelectionSet, v *pg.RefreshToken) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec._RefreshToken(ctx, sel, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
|
|
|
|
return graphql.UnmarshalString(v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
|
|
|
|
res := graphql.MarshalString(v)
|
|
|
|
if res == graphql.Null {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNTask2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTask(ctx context.Context, sel ast.SelectionSet, v pg.Task) graphql.Marshaler {
|
|
|
|
return ec._Task(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNTask2ᚕgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTaskᚄ(ctx context.Context, sel ast.SelectionSet, v []pg.Task) graphql.Marshaler {
|
|
|
|
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.marshalNTask2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTask(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNTask2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTask(ctx context.Context, sel ast.SelectionSet, v *pg.Task) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec._Task(ctx, sel, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNTaskGroup2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTaskGroup(ctx context.Context, sel ast.SelectionSet, v pg.TaskGroup) graphql.Marshaler {
|
|
|
|
return ec._TaskGroup(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNTaskGroup2ᚕgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTaskGroupᚄ(ctx context.Context, sel ast.SelectionSet, v []pg.TaskGroup) graphql.Marshaler {
|
|
|
|
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.marshalNTaskGroup2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTaskGroup(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNTaskGroup2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTaskGroup(ctx context.Context, sel ast.SelectionSet, v *pg.TaskGroup) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec._TaskGroup(ctx, sel, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNTeam2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTeam(ctx context.Context, sel ast.SelectionSet, v pg.Team) graphql.Marshaler {
|
|
|
|
return ec._Team(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNTeam2ᚕgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTeamᚄ(ctx context.Context, sel ast.SelectionSet, v []pg.Team) graphql.Marshaler {
|
|
|
|
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.marshalNTeam2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTeam(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNTeam2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐTeam(ctx context.Context, sel ast.SelectionSet, v *pg.Team) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec._Team(ctx, sel, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
|
|
|
|
return graphql.UnmarshalTime(v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
|
|
|
|
res := graphql.MarshalTime(v)
|
|
|
|
if res == graphql.Null {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNUUID2githubᚗcomᚋgoogleᚋuuidᚐUUID(ctx context.Context, v interface{}) (uuid.UUID, error) {
|
|
|
|
return UnmarshalUUID(v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNUUID2githubᚗcomᚋgoogleᚋuuidᚐUUID(ctx context.Context, sel ast.SelectionSet, v uuid.UUID) graphql.Marshaler {
|
|
|
|
res := MarshalUUID(v)
|
|
|
|
if res == graphql.Null {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalNUpdateTaskName2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐUpdateTaskName(ctx context.Context, v interface{}) (UpdateTaskName, error) {
|
|
|
|
return ec.unmarshalInputUpdateTaskName(ctx, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNUserAccount2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐUserAccount(ctx context.Context, sel ast.SelectionSet, v pg.UserAccount) graphql.Marshaler {
|
|
|
|
return ec._UserAccount(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNUserAccount2ᚕgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐUserAccountᚄ(ctx context.Context, sel ast.SelectionSet, v []pg.UserAccount) graphql.Marshaler {
|
|
|
|
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.marshalNUserAccount2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐUserAccount(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalNUserAccount2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋpgᚐUserAccount(ctx context.Context, sel ast.SelectionSet, v *pg.UserAccount) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec._UserAccount(ctx, sel, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
|
|
|
|
return ec.___Directive(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
|
|
|
|
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.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
|
|
|
|
return graphql.UnmarshalString(v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
|
|
|
|
res := graphql.MarshalString(v)
|
|
|
|
if res == graphql.Null {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
|
|
|
|
var vSlice []interface{}
|
|
|
|
if v != nil {
|
|
|
|
if tmp1, ok := v.([]interface{}); ok {
|
|
|
|
vSlice = tmp1
|
|
|
|
} else {
|
|
|
|
vSlice = []interface{}{v}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
var err error
|
|
|
|
res := make([]string, len(vSlice))
|
|
|
|
for i := range vSlice {
|
|
|
|
res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
|
|
|
|
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.marshalN__DirectiveLocation2string(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
|
|
|
|
return ec.___EnumValue(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
|
|
|
|
return ec.___Field(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
|
|
|
|
return ec.___InputValue(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
|
|
|
|
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.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
|
|
|
|
return ec.___Type(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
|
|
|
|
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.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec.___Type(ctx, sel, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
|
|
|
|
return graphql.UnmarshalString(v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
|
|
|
|
res := graphql.MarshalString(v)
|
|
|
|
if res == graphql.Null {
|
|
|
|
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
|
|
|
|
ec.Errorf(ctx, "must not be null")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
|
|
|
|
return graphql.UnmarshalBoolean(v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
|
|
|
|
return graphql.MarshalBoolean(v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
|
|
|
|
if v == nil {
|
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
res, err := ec.unmarshalOBoolean2bool(ctx, v)
|
|
|
|
return &res, err
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec.marshalOBoolean2bool(ctx, sel, *v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalOProjectsFilter2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐProjectsFilter(ctx context.Context, v interface{}) (ProjectsFilter, error) {
|
|
|
|
return ec.unmarshalInputProjectsFilter(ctx, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalOProjectsFilter2ᚖgithubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐProjectsFilter(ctx context.Context, v interface{}) (*ProjectsFilter, error) {
|
|
|
|
if v == nil {
|
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
res, err := ec.unmarshalOProjectsFilter2githubᚗcomᚋjordanknottᚋprojectᚑcitadelᚋapiᚋgraphᚐProjectsFilter(ctx, v)
|
|
|
|
return &res, err
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
|
|
|
|
return graphql.UnmarshalString(v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
|
|
|
|
return graphql.MarshalString(v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
|
|
|
|
if v == nil {
|
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
res, err := ec.unmarshalOString2string(ctx, v)
|
|
|
|
return &res, err
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec.marshalOString2string(ctx, sel, *v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) 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.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) 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.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) 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.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
|
|
|
|
return ec.___Schema(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec.___Schema(ctx, sel, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
|
|
|
|
return ec.___Type(ctx, sel, &v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) 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.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
|
|
|
|
}
|
|
|
|
if isLen1 {
|
|
|
|
f(i)
|
|
|
|
} else {
|
|
|
|
go f(i)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
|
|
|
|
if v == nil {
|
|
|
|
return graphql.Null
|
|
|
|
}
|
|
|
|
return ec.___Type(ctx, sel, v)
|
|
|
|
}
|
|
|
|
|
|
|
|
// endregion ***************************** type.gotpl *****************************
|