8237 lines
237 KiB
Go
8237 lines
237 KiB
Go
// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
|
|
|
|
package api
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strconv"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
"github.com/99designs/gqlgen/graphql"
|
|
"github.com/99designs/gqlgen/graphql/introspection"
|
|
"github.com/vektah/gqlparser"
|
|
"github.com/vektah/gqlparser/ast"
|
|
"github.com/viktorstrate/photoview/api/graphql/models"
|
|
)
|
|
|
|
// 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 {
|
|
Album() AlbumResolver
|
|
Mutation() MutationResolver
|
|
Photo() PhotoResolver
|
|
Query() QueryResolver
|
|
ShareToken() ShareTokenResolver
|
|
Subscription() SubscriptionResolver
|
|
}
|
|
|
|
type DirectiveRoot struct {
|
|
IsAdmin func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
|
|
}
|
|
|
|
type ComplexityRoot struct {
|
|
Album struct {
|
|
ID func(childComplexity int) int
|
|
Owner func(childComplexity int) int
|
|
ParentAlbum func(childComplexity int) int
|
|
Path func(childComplexity int) int
|
|
Photos func(childComplexity int, filter *models.Filter) int
|
|
Shares func(childComplexity int) int
|
|
SubAlbums func(childComplexity int, filter *models.Filter) int
|
|
Thumbnail func(childComplexity int) int
|
|
Title func(childComplexity int) int
|
|
}
|
|
|
|
AuthorizeResult struct {
|
|
Status func(childComplexity int) int
|
|
Success func(childComplexity int) int
|
|
Token func(childComplexity int) int
|
|
}
|
|
|
|
Mutation struct {
|
|
AuthorizeUser func(childComplexity int, username string, password string) int
|
|
CreateUser func(childComplexity int, username string, rootPath string, password *string, admin bool) int
|
|
DeleteShareToken func(childComplexity int, token string) int
|
|
DeleteUser func(childComplexity int, id int) int
|
|
InitialSetupWizard func(childComplexity int, username string, password string, rootPath string) int
|
|
RegisterUser func(childComplexity int, username string, password string, rootPath string) int
|
|
ScanAll func(childComplexity int) int
|
|
ScanUser func(childComplexity int, userID int) int
|
|
ShareAlbum func(childComplexity int, albumID int, expire *time.Time, password *string) int
|
|
SharePhoto func(childComplexity int, photoID int, expire *time.Time, password *string) int
|
|
UpdateUser func(childComplexity int, id int, username *string, rootPath *string, password *string, admin *bool) int
|
|
}
|
|
|
|
Notification struct {
|
|
Content func(childComplexity int) int
|
|
Header func(childComplexity int) int
|
|
Key func(childComplexity int) int
|
|
Negative func(childComplexity int) int
|
|
Positive func(childComplexity int) int
|
|
Progress func(childComplexity int) int
|
|
Type func(childComplexity int) int
|
|
}
|
|
|
|
Photo struct {
|
|
Album func(childComplexity int) int
|
|
Downloads func(childComplexity int) int
|
|
Exif func(childComplexity int) int
|
|
HighRes func(childComplexity int) int
|
|
ID func(childComplexity int) int
|
|
Path func(childComplexity int) int
|
|
Shares func(childComplexity int) int
|
|
Thumbnail func(childComplexity int) int
|
|
Title func(childComplexity int) int
|
|
}
|
|
|
|
PhotoDownload struct {
|
|
Height func(childComplexity int) int
|
|
Title func(childComplexity int) int
|
|
URL func(childComplexity int) int
|
|
Width func(childComplexity int) int
|
|
}
|
|
|
|
PhotoExif struct {
|
|
Aperture func(childComplexity int) int
|
|
Camera func(childComplexity int) int
|
|
DateShot func(childComplexity int) int
|
|
Exposure func(childComplexity int) int
|
|
FileSize func(childComplexity int) int
|
|
Flash func(childComplexity int) int
|
|
FocalLength func(childComplexity int) int
|
|
Iso func(childComplexity int) int
|
|
Lens func(childComplexity int) int
|
|
Maker func(childComplexity int) int
|
|
Photo func(childComplexity int) int
|
|
}
|
|
|
|
PhotoURL struct {
|
|
Height func(childComplexity int) int
|
|
URL func(childComplexity int) int
|
|
Width func(childComplexity int) int
|
|
}
|
|
|
|
Query struct {
|
|
Album func(childComplexity int, id int) int
|
|
MyAlbums func(childComplexity int, filter *models.Filter, onlyRoot *bool, showEmpty *bool) int
|
|
MyPhotos func(childComplexity int, filter *models.Filter) int
|
|
MyUser func(childComplexity int) int
|
|
Photo func(childComplexity int, id int) int
|
|
ShareToken func(childComplexity int, token string, password *string) int
|
|
SiteInfo func(childComplexity int) int
|
|
User func(childComplexity int, filter *models.Filter) int
|
|
}
|
|
|
|
ScannerResult struct {
|
|
Finished func(childComplexity int) int
|
|
Message func(childComplexity int) int
|
|
Progress func(childComplexity int) int
|
|
Success func(childComplexity int) int
|
|
}
|
|
|
|
ShareToken struct {
|
|
Album func(childComplexity int) int
|
|
Expire func(childComplexity int) int
|
|
ID func(childComplexity int) int
|
|
Owner func(childComplexity int) int
|
|
Photo func(childComplexity int) int
|
|
Token func(childComplexity int) int
|
|
}
|
|
|
|
SiteInfo struct {
|
|
InitialSetup func(childComplexity int) int
|
|
}
|
|
|
|
Subscription struct {
|
|
Notification func(childComplexity int) int
|
|
}
|
|
|
|
User struct {
|
|
Admin func(childComplexity int) int
|
|
ID func(childComplexity int) int
|
|
RootPath func(childComplexity int) int
|
|
Username func(childComplexity int) int
|
|
}
|
|
}
|
|
|
|
type AlbumResolver interface {
|
|
Photos(ctx context.Context, obj *models.Album, filter *models.Filter) ([]*models.Photo, error)
|
|
SubAlbums(ctx context.Context, obj *models.Album, filter *models.Filter) ([]*models.Album, error)
|
|
ParentAlbum(ctx context.Context, obj *models.Album) (*models.Album, error)
|
|
Owner(ctx context.Context, obj *models.Album) (*models.User, error)
|
|
|
|
Thumbnail(ctx context.Context, obj *models.Album) (*models.Photo, error)
|
|
Shares(ctx context.Context, obj *models.Album) ([]*models.ShareToken, error)
|
|
}
|
|
type MutationResolver interface {
|
|
AuthorizeUser(ctx context.Context, username string, password string) (*models.AuthorizeResult, error)
|
|
RegisterUser(ctx context.Context, username string, password string, rootPath string) (*models.AuthorizeResult, error)
|
|
InitialSetupWizard(ctx context.Context, username string, password string, rootPath string) (*models.AuthorizeResult, error)
|
|
ScanAll(ctx context.Context) (*models.ScannerResult, error)
|
|
ScanUser(ctx context.Context, userID int) (*models.ScannerResult, error)
|
|
ShareAlbum(ctx context.Context, albumID int, expire *time.Time, password *string) (*models.ShareToken, error)
|
|
SharePhoto(ctx context.Context, photoID int, expire *time.Time, password *string) (*models.ShareToken, error)
|
|
DeleteShareToken(ctx context.Context, token string) (*models.ShareToken, error)
|
|
UpdateUser(ctx context.Context, id int, username *string, rootPath *string, password *string, admin *bool) (*models.User, error)
|
|
CreateUser(ctx context.Context, username string, rootPath string, password *string, admin bool) (*models.User, error)
|
|
DeleteUser(ctx context.Context, id int) (*models.User, error)
|
|
}
|
|
type PhotoResolver interface {
|
|
Thumbnail(ctx context.Context, obj *models.Photo) (*models.PhotoURL, error)
|
|
HighRes(ctx context.Context, obj *models.Photo) (*models.PhotoURL, error)
|
|
Album(ctx context.Context, obj *models.Photo) (*models.Album, error)
|
|
Exif(ctx context.Context, obj *models.Photo) (*models.PhotoExif, error)
|
|
Shares(ctx context.Context, obj *models.Photo) ([]*models.ShareToken, error)
|
|
Downloads(ctx context.Context, obj *models.Photo) ([]*models.PhotoDownload, error)
|
|
}
|
|
type QueryResolver interface {
|
|
SiteInfo(ctx context.Context) (*models.SiteInfo, error)
|
|
User(ctx context.Context, filter *models.Filter) ([]*models.User, error)
|
|
MyUser(ctx context.Context) (*models.User, error)
|
|
MyAlbums(ctx context.Context, filter *models.Filter, onlyRoot *bool, showEmpty *bool) ([]*models.Album, error)
|
|
Album(ctx context.Context, id int) (*models.Album, error)
|
|
MyPhotos(ctx context.Context, filter *models.Filter) ([]*models.Photo, error)
|
|
Photo(ctx context.Context, id int) (*models.Photo, error)
|
|
ShareToken(ctx context.Context, token string, password *string) (*models.ShareToken, error)
|
|
}
|
|
type ShareTokenResolver interface {
|
|
Owner(ctx context.Context, obj *models.ShareToken) (*models.User, error)
|
|
|
|
Album(ctx context.Context, obj *models.ShareToken) (*models.Album, error)
|
|
Photo(ctx context.Context, obj *models.ShareToken) (*models.Photo, error)
|
|
}
|
|
type SubscriptionResolver interface {
|
|
Notification(ctx context.Context) (<-chan *models.Notification, 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 "Album.id":
|
|
if e.complexity.Album.ID == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Album.ID(childComplexity), true
|
|
|
|
case "Album.owner":
|
|
if e.complexity.Album.Owner == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Album.Owner(childComplexity), true
|
|
|
|
case "Album.parentAlbum":
|
|
if e.complexity.Album.ParentAlbum == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Album.ParentAlbum(childComplexity), true
|
|
|
|
case "Album.path":
|
|
if e.complexity.Album.Path == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Album.Path(childComplexity), true
|
|
|
|
case "Album.photos":
|
|
if e.complexity.Album.Photos == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Album_photos_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Album.Photos(childComplexity, args["filter"].(*models.Filter)), true
|
|
|
|
case "Album.shares":
|
|
if e.complexity.Album.Shares == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Album.Shares(childComplexity), true
|
|
|
|
case "Album.subAlbums":
|
|
if e.complexity.Album.SubAlbums == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Album_subAlbums_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Album.SubAlbums(childComplexity, args["filter"].(*models.Filter)), true
|
|
|
|
case "Album.thumbnail":
|
|
if e.complexity.Album.Thumbnail == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Album.Thumbnail(childComplexity), true
|
|
|
|
case "Album.title":
|
|
if e.complexity.Album.Title == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Album.Title(childComplexity), true
|
|
|
|
case "AuthorizeResult.status":
|
|
if e.complexity.AuthorizeResult.Status == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AuthorizeResult.Status(childComplexity), true
|
|
|
|
case "AuthorizeResult.success":
|
|
if e.complexity.AuthorizeResult.Success == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AuthorizeResult.Success(childComplexity), true
|
|
|
|
case "AuthorizeResult.token":
|
|
if e.complexity.AuthorizeResult.Token == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AuthorizeResult.Token(childComplexity), true
|
|
|
|
case "Mutation.authorizeUser":
|
|
if e.complexity.Mutation.AuthorizeUser == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_authorizeUser_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.AuthorizeUser(childComplexity, args["username"].(string), args["password"].(string)), true
|
|
|
|
case "Mutation.createUser":
|
|
if e.complexity.Mutation.CreateUser == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_createUser_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.CreateUser(childComplexity, args["username"].(string), args["rootPath"].(string), args["password"].(*string), args["admin"].(bool)), true
|
|
|
|
case "Mutation.deleteShareToken":
|
|
if e.complexity.Mutation.DeleteShareToken == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_deleteShareToken_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.DeleteShareToken(childComplexity, args["token"].(string)), true
|
|
|
|
case "Mutation.deleteUser":
|
|
if e.complexity.Mutation.DeleteUser == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_deleteUser_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.DeleteUser(childComplexity, args["id"].(int)), true
|
|
|
|
case "Mutation.initialSetupWizard":
|
|
if e.complexity.Mutation.InitialSetupWizard == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_initialSetupWizard_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.InitialSetupWizard(childComplexity, args["username"].(string), args["password"].(string), args["rootPath"].(string)), true
|
|
|
|
case "Mutation.registerUser":
|
|
if e.complexity.Mutation.RegisterUser == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_registerUser_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.RegisterUser(childComplexity, args["username"].(string), args["password"].(string), args["rootPath"].(string)), true
|
|
|
|
case "Mutation.scanAll":
|
|
if e.complexity.Mutation.ScanAll == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Mutation.ScanAll(childComplexity), true
|
|
|
|
case "Mutation.scanUser":
|
|
if e.complexity.Mutation.ScanUser == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_scanUser_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.ScanUser(childComplexity, args["userId"].(int)), true
|
|
|
|
case "Mutation.shareAlbum":
|
|
if e.complexity.Mutation.ShareAlbum == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_shareAlbum_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.ShareAlbum(childComplexity, args["albumId"].(int), args["expire"].(*time.Time), args["password"].(*string)), true
|
|
|
|
case "Mutation.sharePhoto":
|
|
if e.complexity.Mutation.SharePhoto == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_sharePhoto_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.SharePhoto(childComplexity, args["photoId"].(int), args["expire"].(*time.Time), args["password"].(*string)), true
|
|
|
|
case "Mutation.updateUser":
|
|
if e.complexity.Mutation.UpdateUser == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_updateUser_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.UpdateUser(childComplexity, args["id"].(int), args["username"].(*string), args["rootPath"].(*string), args["password"].(*string), args["admin"].(*bool)), true
|
|
|
|
case "Notification.content":
|
|
if e.complexity.Notification.Content == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Notification.Content(childComplexity), true
|
|
|
|
case "Notification.header":
|
|
if e.complexity.Notification.Header == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Notification.Header(childComplexity), true
|
|
|
|
case "Notification.key":
|
|
if e.complexity.Notification.Key == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Notification.Key(childComplexity), true
|
|
|
|
case "Notification.negative":
|
|
if e.complexity.Notification.Negative == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Notification.Negative(childComplexity), true
|
|
|
|
case "Notification.positive":
|
|
if e.complexity.Notification.Positive == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Notification.Positive(childComplexity), true
|
|
|
|
case "Notification.progress":
|
|
if e.complexity.Notification.Progress == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Notification.Progress(childComplexity), true
|
|
|
|
case "Notification.type":
|
|
if e.complexity.Notification.Type == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Notification.Type(childComplexity), true
|
|
|
|
case "Photo.album":
|
|
if e.complexity.Photo.Album == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Photo.Album(childComplexity), true
|
|
|
|
case "Photo.downloads":
|
|
if e.complexity.Photo.Downloads == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Photo.Downloads(childComplexity), true
|
|
|
|
case "Photo.exif":
|
|
if e.complexity.Photo.Exif == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Photo.Exif(childComplexity), true
|
|
|
|
case "Photo.highRes":
|
|
if e.complexity.Photo.HighRes == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Photo.HighRes(childComplexity), true
|
|
|
|
case "Photo.id":
|
|
if e.complexity.Photo.ID == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Photo.ID(childComplexity), true
|
|
|
|
case "Photo.path":
|
|
if e.complexity.Photo.Path == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Photo.Path(childComplexity), true
|
|
|
|
case "Photo.shares":
|
|
if e.complexity.Photo.Shares == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Photo.Shares(childComplexity), true
|
|
|
|
case "Photo.thumbnail":
|
|
if e.complexity.Photo.Thumbnail == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Photo.Thumbnail(childComplexity), true
|
|
|
|
case "Photo.title":
|
|
if e.complexity.Photo.Title == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Photo.Title(childComplexity), true
|
|
|
|
case "PhotoDownload.height":
|
|
if e.complexity.PhotoDownload.Height == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoDownload.Height(childComplexity), true
|
|
|
|
case "PhotoDownload.title":
|
|
if e.complexity.PhotoDownload.Title == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoDownload.Title(childComplexity), true
|
|
|
|
case "PhotoDownload.url":
|
|
if e.complexity.PhotoDownload.URL == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoDownload.URL(childComplexity), true
|
|
|
|
case "PhotoDownload.width":
|
|
if e.complexity.PhotoDownload.Width == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoDownload.Width(childComplexity), true
|
|
|
|
case "PhotoEXIF.aperture":
|
|
if e.complexity.PhotoExif.Aperture == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoExif.Aperture(childComplexity), true
|
|
|
|
case "PhotoEXIF.camera":
|
|
if e.complexity.PhotoExif.Camera == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoExif.Camera(childComplexity), true
|
|
|
|
case "PhotoEXIF.dateShot":
|
|
if e.complexity.PhotoExif.DateShot == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoExif.DateShot(childComplexity), true
|
|
|
|
case "PhotoEXIF.exposure":
|
|
if e.complexity.PhotoExif.Exposure == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoExif.Exposure(childComplexity), true
|
|
|
|
case "PhotoEXIF.fileSize":
|
|
if e.complexity.PhotoExif.FileSize == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoExif.FileSize(childComplexity), true
|
|
|
|
case "PhotoEXIF.flash":
|
|
if e.complexity.PhotoExif.Flash == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoExif.Flash(childComplexity), true
|
|
|
|
case "PhotoEXIF.focalLength":
|
|
if e.complexity.PhotoExif.FocalLength == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoExif.FocalLength(childComplexity), true
|
|
|
|
case "PhotoEXIF.iso":
|
|
if e.complexity.PhotoExif.Iso == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoExif.Iso(childComplexity), true
|
|
|
|
case "PhotoEXIF.lens":
|
|
if e.complexity.PhotoExif.Lens == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoExif.Lens(childComplexity), true
|
|
|
|
case "PhotoEXIF.maker":
|
|
if e.complexity.PhotoExif.Maker == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoExif.Maker(childComplexity), true
|
|
|
|
case "PhotoEXIF.photo":
|
|
if e.complexity.PhotoExif.Photo == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoExif.Photo(childComplexity), true
|
|
|
|
case "PhotoURL.height":
|
|
if e.complexity.PhotoURL.Height == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoURL.Height(childComplexity), true
|
|
|
|
case "PhotoURL.url":
|
|
if e.complexity.PhotoURL.URL == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoURL.URL(childComplexity), true
|
|
|
|
case "PhotoURL.width":
|
|
if e.complexity.PhotoURL.Width == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PhotoURL.Width(childComplexity), true
|
|
|
|
case "Query.album":
|
|
if e.complexity.Query.Album == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Query_album_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Query.Album(childComplexity, args["id"].(int)), true
|
|
|
|
case "Query.myAlbums":
|
|
if e.complexity.Query.MyAlbums == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Query_myAlbums_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Query.MyAlbums(childComplexity, args["filter"].(*models.Filter), args["onlyRoot"].(*bool), args["showEmpty"].(*bool)), true
|
|
|
|
case "Query.myPhotos":
|
|
if e.complexity.Query.MyPhotos == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Query_myPhotos_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Query.MyPhotos(childComplexity, args["filter"].(*models.Filter)), true
|
|
|
|
case "Query.myUser":
|
|
if e.complexity.Query.MyUser == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Query.MyUser(childComplexity), true
|
|
|
|
case "Query.photo":
|
|
if e.complexity.Query.Photo == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Query_photo_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Query.Photo(childComplexity, args["id"].(int)), true
|
|
|
|
case "Query.shareToken":
|
|
if e.complexity.Query.ShareToken == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Query_shareToken_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Query.ShareToken(childComplexity, args["token"].(string), args["password"].(*string)), true
|
|
|
|
case "Query.siteInfo":
|
|
if e.complexity.Query.SiteInfo == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Query.SiteInfo(childComplexity), true
|
|
|
|
case "Query.user":
|
|
if e.complexity.Query.User == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Query_user_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Query.User(childComplexity, args["filter"].(*models.Filter)), true
|
|
|
|
case "ScannerResult.finished":
|
|
if e.complexity.ScannerResult.Finished == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.ScannerResult.Finished(childComplexity), true
|
|
|
|
case "ScannerResult.message":
|
|
if e.complexity.ScannerResult.Message == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.ScannerResult.Message(childComplexity), true
|
|
|
|
case "ScannerResult.progress":
|
|
if e.complexity.ScannerResult.Progress == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.ScannerResult.Progress(childComplexity), true
|
|
|
|
case "ScannerResult.success":
|
|
if e.complexity.ScannerResult.Success == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.ScannerResult.Success(childComplexity), true
|
|
|
|
case "ShareToken.album":
|
|
if e.complexity.ShareToken.Album == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.ShareToken.Album(childComplexity), true
|
|
|
|
case "ShareToken.expire":
|
|
if e.complexity.ShareToken.Expire == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.ShareToken.Expire(childComplexity), true
|
|
|
|
case "ShareToken.id":
|
|
if e.complexity.ShareToken.ID == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.ShareToken.ID(childComplexity), true
|
|
|
|
case "ShareToken.owner":
|
|
if e.complexity.ShareToken.Owner == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.ShareToken.Owner(childComplexity), true
|
|
|
|
case "ShareToken.photo":
|
|
if e.complexity.ShareToken.Photo == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.ShareToken.Photo(childComplexity), true
|
|
|
|
case "ShareToken.token":
|
|
if e.complexity.ShareToken.Token == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.ShareToken.Token(childComplexity), true
|
|
|
|
case "SiteInfo.initialSetup":
|
|
if e.complexity.SiteInfo.InitialSetup == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SiteInfo.InitialSetup(childComplexity), true
|
|
|
|
case "Subscription.notification":
|
|
if e.complexity.Subscription.Notification == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Subscription.Notification(childComplexity), true
|
|
|
|
case "User.admin":
|
|
if e.complexity.User.Admin == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.User.Admin(childComplexity), true
|
|
|
|
case "User.id":
|
|
if e.complexity.User.ID == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.User.ID(childComplexity), true
|
|
|
|
case "User.rootPath":
|
|
if e.complexity.User.RootPath == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.User.RootPath(childComplexity), true
|
|
|
|
case "User.username":
|
|
if e.complexity.User.Username == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.User.Username(childComplexity), true
|
|
|
|
}
|
|
return 0, false
|
|
}
|
|
|
|
func (e *executableSchema) Query(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
|
|
ec := executionContext{graphql.GetRequestContext(ctx), e}
|
|
|
|
buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
|
|
data := ec._Query(ctx, op.SelectionSet)
|
|
var buf bytes.Buffer
|
|
data.MarshalGQL(&buf)
|
|
return buf.Bytes()
|
|
})
|
|
|
|
return &graphql.Response{
|
|
Data: buf,
|
|
Errors: ec.Errors,
|
|
Extensions: ec.Extensions,
|
|
}
|
|
}
|
|
|
|
func (e *executableSchema) Mutation(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
|
|
ec := executionContext{graphql.GetRequestContext(ctx), e}
|
|
|
|
buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
|
|
data := ec._Mutation(ctx, op.SelectionSet)
|
|
var buf bytes.Buffer
|
|
data.MarshalGQL(&buf)
|
|
return buf.Bytes()
|
|
})
|
|
|
|
return &graphql.Response{
|
|
Data: buf,
|
|
Errors: ec.Errors,
|
|
Extensions: ec.Extensions,
|
|
}
|
|
}
|
|
|
|
func (e *executableSchema) Subscription(ctx context.Context, op *ast.OperationDefinition) func() *graphql.Response {
|
|
ec := executionContext{graphql.GetRequestContext(ctx), e}
|
|
|
|
next := ec._Subscription(ctx, op.SelectionSet)
|
|
if ec.Errors != nil {
|
|
return graphql.OneShot(&graphql.Response{Data: []byte("null"), Errors: ec.Errors})
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
return func() *graphql.Response {
|
|
buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
|
|
buf.Reset()
|
|
data := next()
|
|
|
|
if data == nil {
|
|
return nil
|
|
}
|
|
data.MarshalGQL(&buf)
|
|
return buf.Bytes()
|
|
})
|
|
|
|
if buf == nil {
|
|
return nil
|
|
}
|
|
|
|
return &graphql.Response{
|
|
Data: buf,
|
|
Errors: ec.Errors,
|
|
Extensions: ec.Extensions,
|
|
}
|
|
}
|
|
}
|
|
|
|
type executionContext struct {
|
|
*graphql.RequestContext
|
|
*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 parsedSchema = gqlparser.MustLoadSchema(
|
|
&ast.Source{Name: "graphql/schema.graphql", Input: `directive @isAdmin on FIELD_DEFINITION
|
|
|
|
scalar Time
|
|
|
|
enum OrderDirection {
|
|
ASC
|
|
DESC
|
|
}
|
|
|
|
input Filter {
|
|
order_by: String
|
|
order_direction: OrderDirection
|
|
limit: Int
|
|
offset: Int
|
|
}
|
|
|
|
type Query {
|
|
siteInfo: SiteInfo!
|
|
|
|
"List of registered users, must be admin to call"
|
|
user(filter: Filter): [User!]! @isAdmin
|
|
"Information about the currently logged in user"
|
|
myUser: User!
|
|
|
|
"List of albums owned by the logged in user."
|
|
myAlbums(
|
|
filter: Filter
|
|
"Return only albums from the root directory of the user"
|
|
onlyRoot: Boolean
|
|
"Return also albums with no photos directly in them"
|
|
showEmpty: Boolean
|
|
): [Album!]!
|
|
"Get album by id, user must own the album or be admin"
|
|
album(id: Int!): Album!
|
|
|
|
"List of photos owned by the logged in user"
|
|
myPhotos(filter: Filter): [Photo!]!
|
|
"Get photo by id, user must own the photo or be admin"
|
|
photo(id: Int!): Photo!
|
|
|
|
shareToken(token: String!, password: String): ShareToken!
|
|
}
|
|
|
|
type Mutation {
|
|
authorizeUser(username: String!, password: String!): AuthorizeResult!
|
|
|
|
"Registers a new user, must be admin to call"
|
|
registerUser(
|
|
username: String!
|
|
password: String!
|
|
rootPath: String!
|
|
): AuthorizeResult!
|
|
|
|
"Registers the initial user, can only be called if initialSetup from SiteInfo is true"
|
|
initialSetupWizard(
|
|
username: String!
|
|
password: String!
|
|
rootPath: String!
|
|
): AuthorizeResult
|
|
|
|
"Scan all users for new photos"
|
|
scanAll: ScannerResult! @isAdmin
|
|
"Scan a single user for new photos"
|
|
scanUser(userId: Int!): ScannerResult!
|
|
|
|
"Generate share token for album"
|
|
shareAlbum(albumId: Int!, expire: Time, password: String): ShareToken
|
|
"Generate share token for photo"
|
|
sharePhoto(photoId: Int!, expire: Time, password: String): ShareToken
|
|
"Delete a share token by it's token value"
|
|
deleteShareToken(token: String!): ShareToken
|
|
|
|
updateUser(
|
|
id: Int!
|
|
username: String
|
|
rootPath: String
|
|
password: String
|
|
admin: Boolean
|
|
): User @isAdmin
|
|
createUser(
|
|
username: String!
|
|
rootPath: String!
|
|
password: String
|
|
admin: Boolean!
|
|
): User @isAdmin
|
|
deleteUser(id: Int!): User @isAdmin
|
|
}
|
|
|
|
type Subscription {
|
|
notification: Notification!
|
|
}
|
|
|
|
enum NotificationType {
|
|
Message
|
|
Progress
|
|
}
|
|
|
|
type Notification {
|
|
key: String!
|
|
type: NotificationType!
|
|
header: String!
|
|
content: String!
|
|
progress: Float
|
|
positive: Boolean!
|
|
negative: Boolean!
|
|
}
|
|
|
|
type AuthorizeResult {
|
|
success: Boolean!
|
|
status: String!
|
|
token: String
|
|
}
|
|
|
|
type ScannerResult {
|
|
finished: Boolean!
|
|
success: Boolean!
|
|
progress: Float
|
|
message: String
|
|
}
|
|
|
|
"A token used to publicly access an album or photo"
|
|
type ShareToken {
|
|
id: Int!
|
|
token: String!
|
|
"The user who created the token"
|
|
owner: User!
|
|
"Optional expire date"
|
|
expire: Time
|
|
|
|
"The album this token shares"
|
|
album: Album
|
|
"The photo this token shares"
|
|
photo: Photo
|
|
}
|
|
|
|
"General public information about the site"
|
|
type SiteInfo {
|
|
initialSetup: Boolean!
|
|
}
|
|
|
|
type User {
|
|
id: Int!
|
|
username: String!
|
|
#albums: [Album]
|
|
"Local filepath for the user's photos"
|
|
rootPath: String! @isAdmin
|
|
admin: Boolean!
|
|
#shareTokens: [ShareToken]
|
|
}
|
|
|
|
type Album {
|
|
id: Int!
|
|
title: String!
|
|
"The photos inside this album"
|
|
photos(filter: Filter): [Photo!]!
|
|
"The albums contained in this album"
|
|
subAlbums(filter: Filter): [Album!]!
|
|
"The album witch contains this album"
|
|
parentAlbum: Album
|
|
"The user who owns this album"
|
|
owner: User!
|
|
"The path on the filesystem of the server, where this album is located"
|
|
path: String!
|
|
"An image in this album used for previewing this album"
|
|
thumbnail: Photo
|
|
|
|
shares: [ShareToken]
|
|
}
|
|
|
|
type PhotoURL {
|
|
"URL for previewing the image"
|
|
url: String!
|
|
"Width of the image in pixels"
|
|
width: Int!
|
|
"Height of the image in pixels"
|
|
height: Int!
|
|
}
|
|
|
|
type PhotoDownload {
|
|
title: String!
|
|
width: Int!
|
|
height: Int!
|
|
url: String!
|
|
}
|
|
|
|
type Photo {
|
|
id: Int!
|
|
title: String!
|
|
"Local filepath for the photo"
|
|
path: String!
|
|
"URL to display the photo in a smaller resolution"
|
|
thumbnail: PhotoURL!
|
|
"URL to display the photo in full resolution"
|
|
highRes: PhotoURL!
|
|
"The album that holds the photo"
|
|
album: Album!
|
|
exif: PhotoEXIF
|
|
|
|
shares: [ShareToken!]!
|
|
downloads: [PhotoDownload!]!
|
|
}
|
|
|
|
"EXIF metadata from the camera"
|
|
type PhotoEXIF {
|
|
photo: Photo
|
|
"The model name of the camera"
|
|
camera: String
|
|
"The maker of the camera"
|
|
maker: String
|
|
"The name of the lens"
|
|
lens: String
|
|
dateShot: Time
|
|
"The formatted filesize of the image"
|
|
fileSize: String
|
|
"The exposure time of the image"
|
|
exposure: String
|
|
"The aperature stops of the image"
|
|
aperture: Float
|
|
"The ISO setting of the image"
|
|
iso: Int
|
|
"The focal length of the lens, when the image was taken"
|
|
focalLength: String
|
|
"A formatted description of the flash settings, when the image was taken"
|
|
flash: String
|
|
}
|
|
`},
|
|
)
|
|
|
|
// endregion ************************** generated!.gotpl **************************
|
|
|
|
// region ***************************** args.gotpl *****************************
|
|
|
|
func (ec *executionContext) field_Album_photos_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
var err error
|
|
args := map[string]interface{}{}
|
|
var arg0 *models.Filter
|
|
if tmp, ok := rawArgs["filter"]; ok {
|
|
arg0, err = ec.unmarshalOFilter2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐFilter(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["filter"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Album_subAlbums_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
var err error
|
|
args := map[string]interface{}{}
|
|
var arg0 *models.Filter
|
|
if tmp, ok := rawArgs["filter"]; ok {
|
|
arg0, err = ec.unmarshalOFilter2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐFilter(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["filter"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Mutation_authorizeUser_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["username"]; ok {
|
|
arg0, err = ec.unmarshalNString2string(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["username"] = arg0
|
|
var arg1 string
|
|
if tmp, ok := rawArgs["password"]; ok {
|
|
arg1, err = ec.unmarshalNString2string(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["password"] = arg1
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Mutation_createUser_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["username"]; ok {
|
|
arg0, err = ec.unmarshalNString2string(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["username"] = arg0
|
|
var arg1 string
|
|
if tmp, ok := rawArgs["rootPath"]; ok {
|
|
arg1, err = ec.unmarshalNString2string(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["rootPath"] = arg1
|
|
var arg2 *string
|
|
if tmp, ok := rawArgs["password"]; ok {
|
|
arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["password"] = arg2
|
|
var arg3 bool
|
|
if tmp, ok := rawArgs["admin"]; ok {
|
|
arg3, err = ec.unmarshalNBoolean2bool(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["admin"] = arg3
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Mutation_deleteShareToken_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["token"]; ok {
|
|
arg0, err = ec.unmarshalNString2string(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["token"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Mutation_deleteUser_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
var err error
|
|
args := map[string]interface{}{}
|
|
var arg0 int
|
|
if tmp, ok := rawArgs["id"]; ok {
|
|
arg0, err = ec.unmarshalNInt2int(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["id"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Mutation_initialSetupWizard_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["username"]; ok {
|
|
arg0, err = ec.unmarshalNString2string(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["username"] = arg0
|
|
var arg1 string
|
|
if tmp, ok := rawArgs["password"]; ok {
|
|
arg1, err = ec.unmarshalNString2string(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["password"] = arg1
|
|
var arg2 string
|
|
if tmp, ok := rawArgs["rootPath"]; ok {
|
|
arg2, err = ec.unmarshalNString2string(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["rootPath"] = arg2
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Mutation_registerUser_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["username"]; ok {
|
|
arg0, err = ec.unmarshalNString2string(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["username"] = arg0
|
|
var arg1 string
|
|
if tmp, ok := rawArgs["password"]; ok {
|
|
arg1, err = ec.unmarshalNString2string(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["password"] = arg1
|
|
var arg2 string
|
|
if tmp, ok := rawArgs["rootPath"]; ok {
|
|
arg2, err = ec.unmarshalNString2string(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["rootPath"] = arg2
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Mutation_scanUser_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
var err error
|
|
args := map[string]interface{}{}
|
|
var arg0 int
|
|
if tmp, ok := rawArgs["userId"]; ok {
|
|
arg0, err = ec.unmarshalNInt2int(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["userId"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Mutation_shareAlbum_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
var err error
|
|
args := map[string]interface{}{}
|
|
var arg0 int
|
|
if tmp, ok := rawArgs["albumId"]; ok {
|
|
arg0, err = ec.unmarshalNInt2int(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["albumId"] = arg0
|
|
var arg1 *time.Time
|
|
if tmp, ok := rawArgs["expire"]; ok {
|
|
arg1, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["expire"] = arg1
|
|
var arg2 *string
|
|
if tmp, ok := rawArgs["password"]; ok {
|
|
arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["password"] = arg2
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Mutation_sharePhoto_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
var err error
|
|
args := map[string]interface{}{}
|
|
var arg0 int
|
|
if tmp, ok := rawArgs["photoId"]; ok {
|
|
arg0, err = ec.unmarshalNInt2int(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["photoId"] = arg0
|
|
var arg1 *time.Time
|
|
if tmp, ok := rawArgs["expire"]; ok {
|
|
arg1, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["expire"] = arg1
|
|
var arg2 *string
|
|
if tmp, ok := rawArgs["password"]; ok {
|
|
arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["password"] = arg2
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Mutation_updateUser_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
var err error
|
|
args := map[string]interface{}{}
|
|
var arg0 int
|
|
if tmp, ok := rawArgs["id"]; ok {
|
|
arg0, err = ec.unmarshalNInt2int(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["id"] = arg0
|
|
var arg1 *string
|
|
if tmp, ok := rawArgs["username"]; ok {
|
|
arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["username"] = arg1
|
|
var arg2 *string
|
|
if tmp, ok := rawArgs["rootPath"]; ok {
|
|
arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["rootPath"] = arg2
|
|
var arg3 *string
|
|
if tmp, ok := rawArgs["password"]; ok {
|
|
arg3, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["password"] = arg3
|
|
var arg4 *bool
|
|
if tmp, ok := rawArgs["admin"]; ok {
|
|
arg4, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["admin"] = arg4
|
|
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_album_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
var err error
|
|
args := map[string]interface{}{}
|
|
var arg0 int
|
|
if tmp, ok := rawArgs["id"]; ok {
|
|
arg0, err = ec.unmarshalNInt2int(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["id"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Query_myAlbums_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
var err error
|
|
args := map[string]interface{}{}
|
|
var arg0 *models.Filter
|
|
if tmp, ok := rawArgs["filter"]; ok {
|
|
arg0, err = ec.unmarshalOFilter2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐFilter(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["filter"] = arg0
|
|
var arg1 *bool
|
|
if tmp, ok := rawArgs["onlyRoot"]; ok {
|
|
arg1, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["onlyRoot"] = arg1
|
|
var arg2 *bool
|
|
if tmp, ok := rawArgs["showEmpty"]; ok {
|
|
arg2, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["showEmpty"] = arg2
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Query_myPhotos_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
var err error
|
|
args := map[string]interface{}{}
|
|
var arg0 *models.Filter
|
|
if tmp, ok := rawArgs["filter"]; ok {
|
|
arg0, err = ec.unmarshalOFilter2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐFilter(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["filter"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Query_photo_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
var err error
|
|
args := map[string]interface{}{}
|
|
var arg0 int
|
|
if tmp, ok := rawArgs["id"]; ok {
|
|
arg0, err = ec.unmarshalNInt2int(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["id"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Query_shareToken_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["token"]; ok {
|
|
arg0, err = ec.unmarshalNString2string(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["token"] = arg0
|
|
var arg1 *string
|
|
if tmp, ok := rawArgs["password"]; ok {
|
|
arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["password"] = arg1
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Query_user_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
var err error
|
|
args := map[string]interface{}{}
|
|
var arg0 *models.Filter
|
|
if tmp, ok := rawArgs["filter"]; ok {
|
|
arg0, err = ec.unmarshalOFilter2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐFilter(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["filter"] = 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) _Album_id(ctx context.Context, field graphql.CollectedField, obj *models.Album) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Album",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.ID(), nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(int)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNInt2int(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Album_title(ctx context.Context, field graphql.CollectedField, obj *models.Album) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Album",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Title, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Album_photos(ctx context.Context, field graphql.CollectedField, obj *models.Album) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Album",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Album_photos_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Album().Photos(rctx, obj, args["filter"].(*models.Filter))
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]*models.Photo)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNPhoto2ᚕᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhotoᚄ(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Album_subAlbums(ctx context.Context, field graphql.CollectedField, obj *models.Album) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Album",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Album_subAlbums_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Album().SubAlbums(rctx, obj, args["filter"].(*models.Filter))
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]*models.Album)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNAlbum2ᚕᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAlbumᚄ(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Album_parentAlbum(ctx context.Context, field graphql.CollectedField, obj *models.Album) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Album",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Album().ParentAlbum(rctx, obj)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.Album)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOAlbum2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAlbum(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Album_owner(ctx context.Context, field graphql.CollectedField, obj *models.Album) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Album",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Album().Owner(rctx, obj)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.User)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNUser2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐUser(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Album_path(ctx context.Context, field graphql.CollectedField, obj *models.Album) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Album",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Path, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Album_thumbnail(ctx context.Context, field graphql.CollectedField, obj *models.Album) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Album",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Album().Thumbnail(rctx, obj)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.Photo)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOPhoto2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhoto(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Album_shares(ctx context.Context, field graphql.CollectedField, obj *models.Album) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Album",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Album().Shares(rctx, obj)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]*models.ShareToken)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOShareToken2ᚕᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐShareToken(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _AuthorizeResult_success(ctx context.Context, field graphql.CollectedField, obj *models.AuthorizeResult) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "AuthorizeResult",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Success, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(bool)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _AuthorizeResult_status(ctx context.Context, field graphql.CollectedField, obj *models.AuthorizeResult) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "AuthorizeResult",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Status, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _AuthorizeResult_token(ctx context.Context, field graphql.CollectedField, obj *models.AuthorizeResult) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "AuthorizeResult",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Token, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_authorizeUser(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_authorizeUser_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().AuthorizeUser(rctx, args["username"].(string), args["password"].(string))
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.AuthorizeResult)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNAuthorizeResult2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAuthorizeResult(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_registerUser(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_registerUser_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().RegisterUser(rctx, args["username"].(string), args["password"].(string), args["rootPath"].(string))
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.AuthorizeResult)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNAuthorizeResult2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAuthorizeResult(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_initialSetupWizard(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_initialSetupWizard_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().InitialSetupWizard(rctx, args["username"].(string), args["password"].(string), args["rootPath"].(string))
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.AuthorizeResult)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOAuthorizeResult2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAuthorizeResult(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_scanAll(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
directive0 := func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().ScanAll(rctx)
|
|
}
|
|
directive1 := func(ctx context.Context) (interface{}, error) {
|
|
if ec.directives.IsAdmin == nil {
|
|
return nil, errors.New("directive isAdmin is not implemented")
|
|
}
|
|
return ec.directives.IsAdmin(ctx, nil, directive0)
|
|
}
|
|
|
|
tmp, err := directive1(rctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if tmp == nil {
|
|
return nil, nil
|
|
}
|
|
if data, ok := tmp.(*models.ScannerResult); ok {
|
|
return data, nil
|
|
}
|
|
return nil, fmt.Errorf(`unexpected type %T from directive, should be *github.com/viktorstrate/photoview/api/graphql/models.ScannerResult`, tmp)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.ScannerResult)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNScannerResult2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐScannerResult(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_scanUser(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_scanUser_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().ScanUser(rctx, args["userId"].(int))
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.ScannerResult)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNScannerResult2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐScannerResult(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_shareAlbum(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_shareAlbum_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().ShareAlbum(rctx, args["albumId"].(int), args["expire"].(*time.Time), args["password"].(*string))
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.ShareToken)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOShareToken2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐShareToken(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_sharePhoto(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_sharePhoto_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().SharePhoto(rctx, args["photoId"].(int), args["expire"].(*time.Time), args["password"].(*string))
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.ShareToken)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOShareToken2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐShareToken(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_deleteShareToken(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_deleteShareToken_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().DeleteShareToken(rctx, args["token"].(string))
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.ShareToken)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOShareToken2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐShareToken(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_updateUser(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_updateUser_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
directive0 := func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().UpdateUser(rctx, args["id"].(int), args["username"].(*string), args["rootPath"].(*string), args["password"].(*string), args["admin"].(*bool))
|
|
}
|
|
directive1 := func(ctx context.Context) (interface{}, error) {
|
|
if ec.directives.IsAdmin == nil {
|
|
return nil, errors.New("directive isAdmin is not implemented")
|
|
}
|
|
return ec.directives.IsAdmin(ctx, nil, directive0)
|
|
}
|
|
|
|
tmp, err := directive1(rctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if tmp == nil {
|
|
return nil, nil
|
|
}
|
|
if data, ok := tmp.(*models.User); ok {
|
|
return data, nil
|
|
}
|
|
return nil, fmt.Errorf(`unexpected type %T from directive, should be *github.com/viktorstrate/photoview/api/graphql/models.User`, tmp)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.User)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOUser2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐUser(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_createUser(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_createUser_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
directive0 := func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().CreateUser(rctx, args["username"].(string), args["rootPath"].(string), args["password"].(*string), args["admin"].(bool))
|
|
}
|
|
directive1 := func(ctx context.Context) (interface{}, error) {
|
|
if ec.directives.IsAdmin == nil {
|
|
return nil, errors.New("directive isAdmin is not implemented")
|
|
}
|
|
return ec.directives.IsAdmin(ctx, nil, directive0)
|
|
}
|
|
|
|
tmp, err := directive1(rctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if tmp == nil {
|
|
return nil, nil
|
|
}
|
|
if data, ok := tmp.(*models.User); ok {
|
|
return data, nil
|
|
}
|
|
return nil, fmt.Errorf(`unexpected type %T from directive, should be *github.com/viktorstrate/photoview/api/graphql/models.User`, tmp)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.User)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOUser2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐUser(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_deleteUser(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_deleteUser_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
directive0 := func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().DeleteUser(rctx, args["id"].(int))
|
|
}
|
|
directive1 := func(ctx context.Context) (interface{}, error) {
|
|
if ec.directives.IsAdmin == nil {
|
|
return nil, errors.New("directive isAdmin is not implemented")
|
|
}
|
|
return ec.directives.IsAdmin(ctx, nil, directive0)
|
|
}
|
|
|
|
tmp, err := directive1(rctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if tmp == nil {
|
|
return nil, nil
|
|
}
|
|
if data, ok := tmp.(*models.User); ok {
|
|
return data, nil
|
|
}
|
|
return nil, fmt.Errorf(`unexpected type %T from directive, should be *github.com/viktorstrate/photoview/api/graphql/models.User`, tmp)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.User)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOUser2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐUser(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Notification_key(ctx context.Context, field graphql.CollectedField, obj *models.Notification) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Notification",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Key, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Notification_type(ctx context.Context, field graphql.CollectedField, obj *models.Notification) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Notification",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(models.NotificationType)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNNotificationType2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐNotificationType(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Notification_header(ctx context.Context, field graphql.CollectedField, obj *models.Notification) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Notification",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Header, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Notification_content(ctx context.Context, field graphql.CollectedField, obj *models.Notification) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Notification",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Content, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Notification_progress(ctx context.Context, field graphql.CollectedField, obj *models.Notification) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Notification",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Progress, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*float64)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOFloat2ᚖfloat64(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Notification_positive(ctx context.Context, field graphql.CollectedField, obj *models.Notification) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Notification",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Positive, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(bool)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Notification_negative(ctx context.Context, field graphql.CollectedField, obj *models.Notification) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Notification",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Negative, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(bool)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Photo_id(ctx context.Context, field graphql.CollectedField, obj *models.Photo) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Photo",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.ID(), nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(int)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNInt2int(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Photo_title(ctx context.Context, field graphql.CollectedField, obj *models.Photo) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Photo",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Title, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Photo_path(ctx context.Context, field graphql.CollectedField, obj *models.Photo) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Photo",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Path, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Photo_thumbnail(ctx context.Context, field graphql.CollectedField, obj *models.Photo) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Photo",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Photo().Thumbnail(rctx, obj)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.PhotoURL)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNPhotoURL2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhotoURL(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Photo_highRes(ctx context.Context, field graphql.CollectedField, obj *models.Photo) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Photo",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Photo().HighRes(rctx, obj)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.PhotoURL)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNPhotoURL2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhotoURL(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Photo_album(ctx context.Context, field graphql.CollectedField, obj *models.Photo) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Photo",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Photo().Album(rctx, obj)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.Album)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNAlbum2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAlbum(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Photo_exif(ctx context.Context, field graphql.CollectedField, obj *models.Photo) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Photo",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Photo().Exif(rctx, obj)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.PhotoExif)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOPhotoEXIF2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhotoExif(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Photo_shares(ctx context.Context, field graphql.CollectedField, obj *models.Photo) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Photo",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Photo().Shares(rctx, obj)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]*models.ShareToken)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNShareToken2ᚕᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐShareTokenᚄ(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Photo_downloads(ctx context.Context, field graphql.CollectedField, obj *models.Photo) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Photo",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Photo().Downloads(rctx, obj)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]*models.PhotoDownload)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNPhotoDownload2ᚕᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhotoDownloadᚄ(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoDownload_title(ctx context.Context, field graphql.CollectedField, obj *models.PhotoDownload) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoDownload",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Title, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoDownload_width(ctx context.Context, field graphql.CollectedField, obj *models.PhotoDownload) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoDownload",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Width, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(int)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNInt2int(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoDownload_height(ctx context.Context, field graphql.CollectedField, obj *models.PhotoDownload) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoDownload",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Height, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(int)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNInt2int(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoDownload_url(ctx context.Context, field graphql.CollectedField, obj *models.PhotoDownload) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoDownload",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.URL, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoEXIF_photo(ctx context.Context, field graphql.CollectedField, obj *models.PhotoExif) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoEXIF",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Photo, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.Photo)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOPhoto2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhoto(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoEXIF_camera(ctx context.Context, field graphql.CollectedField, obj *models.PhotoExif) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoEXIF",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Camera, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoEXIF_maker(ctx context.Context, field graphql.CollectedField, obj *models.PhotoExif) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoEXIF",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Maker, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoEXIF_lens(ctx context.Context, field graphql.CollectedField, obj *models.PhotoExif) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoEXIF",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Lens, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoEXIF_dateShot(ctx context.Context, field graphql.CollectedField, obj *models.PhotoExif) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoEXIF",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.DateShot, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*time.Time)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoEXIF_fileSize(ctx context.Context, field graphql.CollectedField, obj *models.PhotoExif) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoEXIF",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.FileSize, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoEXIF_exposure(ctx context.Context, field graphql.CollectedField, obj *models.PhotoExif) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoEXIF",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Exposure, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoEXIF_aperture(ctx context.Context, field graphql.CollectedField, obj *models.PhotoExif) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoEXIF",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Aperture, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*float64)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOFloat2ᚖfloat64(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoEXIF_iso(ctx context.Context, field graphql.CollectedField, obj *models.PhotoExif) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoEXIF",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Iso, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*int)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoEXIF_focalLength(ctx context.Context, field graphql.CollectedField, obj *models.PhotoExif) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoEXIF",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.FocalLength, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoEXIF_flash(ctx context.Context, field graphql.CollectedField, obj *models.PhotoExif) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoEXIF",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Flash, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoURL_url(ctx context.Context, field graphql.CollectedField, obj *models.PhotoURL) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoURL",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.URL(), nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoURL_width(ctx context.Context, field graphql.CollectedField, obj *models.PhotoURL) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoURL",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Width, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(int)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNInt2int(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PhotoURL_height(ctx context.Context, field graphql.CollectedField, obj *models.PhotoURL) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PhotoURL",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Height, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(int)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNInt2int(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Query_siteInfo(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Query",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Query().SiteInfo(rctx)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.SiteInfo)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNSiteInfo2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐSiteInfo(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Query_user(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Query",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Query_user_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
directive0 := func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Query().User(rctx, args["filter"].(*models.Filter))
|
|
}
|
|
directive1 := func(ctx context.Context) (interface{}, error) {
|
|
if ec.directives.IsAdmin == nil {
|
|
return nil, errors.New("directive isAdmin is not implemented")
|
|
}
|
|
return ec.directives.IsAdmin(ctx, nil, directive0)
|
|
}
|
|
|
|
tmp, err := directive1(rctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if tmp == nil {
|
|
return nil, nil
|
|
}
|
|
if data, ok := tmp.([]*models.User); ok {
|
|
return data, nil
|
|
}
|
|
return nil, fmt.Errorf(`unexpected type %T from directive, should be []*github.com/viktorstrate/photoview/api/graphql/models.User`, tmp)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]*models.User)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNUser2ᚕᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐUserᚄ(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Query_myUser(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Query",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Query().MyUser(rctx)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.User)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNUser2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐUser(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Query_myAlbums(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Query",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Query_myAlbums_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Query().MyAlbums(rctx, args["filter"].(*models.Filter), args["onlyRoot"].(*bool), args["showEmpty"].(*bool))
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]*models.Album)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNAlbum2ᚕᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAlbumᚄ(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Query_album(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Query",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Query_album_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Query().Album(rctx, args["id"].(int))
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.Album)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNAlbum2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAlbum(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Query_myPhotos(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Query",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Query_myPhotos_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Query().MyPhotos(rctx, args["filter"].(*models.Filter))
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]*models.Photo)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNPhoto2ᚕᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhotoᚄ(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Query_photo(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Query",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Query_photo_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Query().Photo(rctx, args["id"].(int))
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.Photo)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNPhoto2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhoto(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Query_shareToken(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Query",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Query_shareToken_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Query().ShareToken(rctx, args["token"].(string), args["password"].(*string))
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.ShareToken)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNShareToken2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐShareToken(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Query",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Query___type_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Query",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _ScannerResult_finished(ctx context.Context, field graphql.CollectedField, obj *models.ScannerResult) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "ScannerResult",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Finished, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(bool)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _ScannerResult_success(ctx context.Context, field graphql.CollectedField, obj *models.ScannerResult) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "ScannerResult",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Success, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(bool)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _ScannerResult_progress(ctx context.Context, field graphql.CollectedField, obj *models.ScannerResult) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "ScannerResult",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Progress, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*float64)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOFloat2ᚖfloat64(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _ScannerResult_message(ctx context.Context, field graphql.CollectedField, obj *models.ScannerResult) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "ScannerResult",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Message, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _ShareToken_id(ctx context.Context, field graphql.CollectedField, obj *models.ShareToken) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "ShareToken",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.ID(), nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(int)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNInt2int(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _ShareToken_token(ctx context.Context, field graphql.CollectedField, obj *models.ShareToken) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "ShareToken",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Token(), nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _ShareToken_owner(ctx context.Context, field graphql.CollectedField, obj *models.ShareToken) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "ShareToken",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.ShareToken().Owner(rctx, obj)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.User)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNUser2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐUser(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _ShareToken_expire(ctx context.Context, field graphql.CollectedField, obj *models.ShareToken) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "ShareToken",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Expire, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*time.Time)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _ShareToken_album(ctx context.Context, field graphql.CollectedField, obj *models.ShareToken) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "ShareToken",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.ShareToken().Album(rctx, obj)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.Album)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOAlbum2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAlbum(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _ShareToken_photo(ctx context.Context, field graphql.CollectedField, obj *models.ShareToken) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "ShareToken",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.ShareToken().Photo(rctx, obj)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.Photo)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOPhoto2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhoto(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _SiteInfo_initialSetup(ctx context.Context, field graphql.CollectedField, obj *models.SiteInfo) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SiteInfo",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.InitialSetup, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(bool)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Subscription_notification(ctx context.Context, field graphql.CollectedField) (ret func() graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Subscription",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Subscription().Notification(rctx)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return nil
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return nil
|
|
}
|
|
return func() graphql.Marshaler {
|
|
res, ok := <-resTmp.(<-chan *models.Notification)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
return graphql.WriterFunc(func(w io.Writer) {
|
|
w.Write([]byte{'{'})
|
|
graphql.MarshalString(field.Alias).MarshalGQL(w)
|
|
w.Write([]byte{':'})
|
|
ec.marshalNNotification2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐNotification(ctx, field.Selections, res).MarshalGQL(w)
|
|
w.Write([]byte{'}'})
|
|
})
|
|
}
|
|
}
|
|
|
|
func (ec *executionContext) _User_id(ctx context.Context, field graphql.CollectedField, obj *models.User) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "User",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.ID(), nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(int)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNInt2int(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _User_username(ctx context.Context, field graphql.CollectedField, obj *models.User) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "User",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _User_rootPath(ctx context.Context, field graphql.CollectedField, obj *models.User) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "User",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
directive0 := func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.RootPath, nil
|
|
}
|
|
directive1 := func(ctx context.Context) (interface{}, error) {
|
|
if ec.directives.IsAdmin == nil {
|
|
return nil, errors.New("directive isAdmin is not implemented")
|
|
}
|
|
return ec.directives.IsAdmin(ctx, obj, directive0)
|
|
}
|
|
|
|
tmp, err := directive1(rctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if tmp == nil {
|
|
return nil, nil
|
|
}
|
|
if data, ok := tmp.(string); ok {
|
|
return data, nil
|
|
}
|
|
return nil, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp)
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _User_admin(ctx context.Context, field graphql.CollectedField, obj *models.User) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "User",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return obj.Admin, nil
|
|
})
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(bool)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Directive",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Directive",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Directive",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Directive",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]introspection.InputValue)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__EnumValue",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__EnumValue",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__EnumValue",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(bool)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__EnumValue",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Field",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Field",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Field",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]introspection.InputValue)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Field",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*introspection.Type)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Field",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(bool)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Field",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__InputValue",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__InputValue",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__InputValue",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*introspection.Type)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__InputValue",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: false,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Schema",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]introspection.Type)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Schema",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*introspection.Type)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Schema",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Schema",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Schema",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]introspection.Directive)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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 !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field___Type_fields_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
|
|
if err != nil {
|
|
ec.Error(ctx, err)
|
|
return graphql.Null
|
|
}
|
|
rctx.Args = args
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
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) {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = graphql.Null
|
|
}
|
|
ec.Tracer.EndFieldExecution(ctx)
|
|
}()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
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)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
}
|
|
|
|
// endregion **************************** field.gotpl *****************************
|
|
|
|
// region **************************** input.gotpl *****************************
|
|
|
|
func (ec *executionContext) unmarshalInputFilter(ctx context.Context, obj interface{}) (models.Filter, error) {
|
|
var it models.Filter
|
|
var asMap = obj.(map[string]interface{})
|
|
|
|
for k, v := range asMap {
|
|
switch k {
|
|
case "order_by":
|
|
var err error
|
|
it.OrderBy, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "order_direction":
|
|
var err error
|
|
it.OrderDirection, err = ec.unmarshalOOrderDirection2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐOrderDirection(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "limit":
|
|
var err error
|
|
it.Limit, err = ec.unmarshalOInt2ᚖint(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "offset":
|
|
var err error
|
|
it.Offset, err = ec.unmarshalOInt2ᚖint(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
}
|
|
}
|
|
|
|
return it, nil
|
|
}
|
|
|
|
// endregion **************************** input.gotpl *****************************
|
|
|
|
// region ************************** interface.gotpl ***************************
|
|
|
|
// endregion ************************** interface.gotpl ***************************
|
|
|
|
// region **************************** object.gotpl ****************************
|
|
|
|
var albumImplementors = []string{"Album"}
|
|
|
|
func (ec *executionContext) _Album(ctx context.Context, sel ast.SelectionSet, obj *models.Album) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, albumImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("Album")
|
|
case "id":
|
|
out.Values[i] = ec._Album_id(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "title":
|
|
out.Values[i] = ec._Album_title(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "photos":
|
|
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._Album_photos(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "subAlbums":
|
|
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._Album_subAlbums(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "parentAlbum":
|
|
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._Album_parentAlbum(ctx, field, obj)
|
|
return res
|
|
})
|
|
case "owner":
|
|
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._Album_owner(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "path":
|
|
out.Values[i] = ec._Album_path(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "thumbnail":
|
|
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._Album_thumbnail(ctx, field, obj)
|
|
return res
|
|
})
|
|
case "shares":
|
|
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._Album_shares(ctx, field, obj)
|
|
return res
|
|
})
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var authorizeResultImplementors = []string{"AuthorizeResult"}
|
|
|
|
func (ec *executionContext) _AuthorizeResult(ctx context.Context, sel ast.SelectionSet, obj *models.AuthorizeResult) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, authorizeResultImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("AuthorizeResult")
|
|
case "success":
|
|
out.Values[i] = ec._AuthorizeResult_success(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "status":
|
|
out.Values[i] = ec._AuthorizeResult_status(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "token":
|
|
out.Values[i] = ec._AuthorizeResult_token(ctx, field, obj)
|
|
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.RequestContext, sel, mutationImplementors)
|
|
|
|
ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
|
|
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 "authorizeUser":
|
|
out.Values[i] = ec._Mutation_authorizeUser(ctx, field)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "registerUser":
|
|
out.Values[i] = ec._Mutation_registerUser(ctx, field)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "initialSetupWizard":
|
|
out.Values[i] = ec._Mutation_initialSetupWizard(ctx, field)
|
|
case "scanAll":
|
|
out.Values[i] = ec._Mutation_scanAll(ctx, field)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "scanUser":
|
|
out.Values[i] = ec._Mutation_scanUser(ctx, field)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "shareAlbum":
|
|
out.Values[i] = ec._Mutation_shareAlbum(ctx, field)
|
|
case "sharePhoto":
|
|
out.Values[i] = ec._Mutation_sharePhoto(ctx, field)
|
|
case "deleteShareToken":
|
|
out.Values[i] = ec._Mutation_deleteShareToken(ctx, field)
|
|
case "updateUser":
|
|
out.Values[i] = ec._Mutation_updateUser(ctx, field)
|
|
case "createUser":
|
|
out.Values[i] = ec._Mutation_createUser(ctx, field)
|
|
case "deleteUser":
|
|
out.Values[i] = ec._Mutation_deleteUser(ctx, field)
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var notificationImplementors = []string{"Notification"}
|
|
|
|
func (ec *executionContext) _Notification(ctx context.Context, sel ast.SelectionSet, obj *models.Notification) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, notificationImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("Notification")
|
|
case "key":
|
|
out.Values[i] = ec._Notification_key(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "type":
|
|
out.Values[i] = ec._Notification_type(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "header":
|
|
out.Values[i] = ec._Notification_header(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "content":
|
|
out.Values[i] = ec._Notification_content(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "progress":
|
|
out.Values[i] = ec._Notification_progress(ctx, field, obj)
|
|
case "positive":
|
|
out.Values[i] = ec._Notification_positive(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "negative":
|
|
out.Values[i] = ec._Notification_negative(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 photoImplementors = []string{"Photo"}
|
|
|
|
func (ec *executionContext) _Photo(ctx context.Context, sel ast.SelectionSet, obj *models.Photo) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, photoImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("Photo")
|
|
case "id":
|
|
out.Values[i] = ec._Photo_id(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "title":
|
|
out.Values[i] = ec._Photo_title(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "path":
|
|
out.Values[i] = ec._Photo_path(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "thumbnail":
|
|
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._Photo_thumbnail(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "highRes":
|
|
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._Photo_highRes(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "album":
|
|
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._Photo_album(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "exif":
|
|
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._Photo_exif(ctx, field, obj)
|
|
return res
|
|
})
|
|
case "shares":
|
|
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._Photo_shares(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "downloads":
|
|
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._Photo_downloads(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 photoDownloadImplementors = []string{"PhotoDownload"}
|
|
|
|
func (ec *executionContext) _PhotoDownload(ctx context.Context, sel ast.SelectionSet, obj *models.PhotoDownload) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, photoDownloadImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("PhotoDownload")
|
|
case "title":
|
|
out.Values[i] = ec._PhotoDownload_title(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "width":
|
|
out.Values[i] = ec._PhotoDownload_width(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "height":
|
|
out.Values[i] = ec._PhotoDownload_height(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "url":
|
|
out.Values[i] = ec._PhotoDownload_url(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 photoEXIFImplementors = []string{"PhotoEXIF"}
|
|
|
|
func (ec *executionContext) _PhotoEXIF(ctx context.Context, sel ast.SelectionSet, obj *models.PhotoExif) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, photoEXIFImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("PhotoEXIF")
|
|
case "photo":
|
|
out.Values[i] = ec._PhotoEXIF_photo(ctx, field, obj)
|
|
case "camera":
|
|
out.Values[i] = ec._PhotoEXIF_camera(ctx, field, obj)
|
|
case "maker":
|
|
out.Values[i] = ec._PhotoEXIF_maker(ctx, field, obj)
|
|
case "lens":
|
|
out.Values[i] = ec._PhotoEXIF_lens(ctx, field, obj)
|
|
case "dateShot":
|
|
out.Values[i] = ec._PhotoEXIF_dateShot(ctx, field, obj)
|
|
case "fileSize":
|
|
out.Values[i] = ec._PhotoEXIF_fileSize(ctx, field, obj)
|
|
case "exposure":
|
|
out.Values[i] = ec._PhotoEXIF_exposure(ctx, field, obj)
|
|
case "aperture":
|
|
out.Values[i] = ec._PhotoEXIF_aperture(ctx, field, obj)
|
|
case "iso":
|
|
out.Values[i] = ec._PhotoEXIF_iso(ctx, field, obj)
|
|
case "focalLength":
|
|
out.Values[i] = ec._PhotoEXIF_focalLength(ctx, field, obj)
|
|
case "flash":
|
|
out.Values[i] = ec._PhotoEXIF_flash(ctx, field, obj)
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var photoURLImplementors = []string{"PhotoURL"}
|
|
|
|
func (ec *executionContext) _PhotoURL(ctx context.Context, sel ast.SelectionSet, obj *models.PhotoURL) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, photoURLImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("PhotoURL")
|
|
case "url":
|
|
out.Values[i] = ec._PhotoURL_url(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "width":
|
|
out.Values[i] = ec._PhotoURL_width(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "height":
|
|
out.Values[i] = ec._PhotoURL_height(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 queryImplementors = []string{"Query"}
|
|
|
|
func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, queryImplementors)
|
|
|
|
ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
|
|
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 "siteInfo":
|
|
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_siteInfo(ctx, field)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "user":
|
|
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_user(ctx, field)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "myUser":
|
|
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_myUser(ctx, field)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "myAlbums":
|
|
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_myAlbums(ctx, field)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "album":
|
|
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_album(ctx, field)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "myPhotos":
|
|
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_myPhotos(ctx, field)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "photo":
|
|
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_photo(ctx, field)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "shareToken":
|
|
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_shareToken(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 scannerResultImplementors = []string{"ScannerResult"}
|
|
|
|
func (ec *executionContext) _ScannerResult(ctx context.Context, sel ast.SelectionSet, obj *models.ScannerResult) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, scannerResultImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("ScannerResult")
|
|
case "finished":
|
|
out.Values[i] = ec._ScannerResult_finished(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "success":
|
|
out.Values[i] = ec._ScannerResult_success(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "progress":
|
|
out.Values[i] = ec._ScannerResult_progress(ctx, field, obj)
|
|
case "message":
|
|
out.Values[i] = ec._ScannerResult_message(ctx, field, obj)
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var shareTokenImplementors = []string{"ShareToken"}
|
|
|
|
func (ec *executionContext) _ShareToken(ctx context.Context, sel ast.SelectionSet, obj *models.ShareToken) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, shareTokenImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("ShareToken")
|
|
case "id":
|
|
out.Values[i] = ec._ShareToken_id(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "token":
|
|
out.Values[i] = ec._ShareToken_token(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "owner":
|
|
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._ShareToken_owner(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "expire":
|
|
out.Values[i] = ec._ShareToken_expire(ctx, field, obj)
|
|
case "album":
|
|
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._ShareToken_album(ctx, field, obj)
|
|
return res
|
|
})
|
|
case "photo":
|
|
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._ShareToken_photo(ctx, field, obj)
|
|
return res
|
|
})
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var siteInfoImplementors = []string{"SiteInfo"}
|
|
|
|
func (ec *executionContext) _SiteInfo(ctx context.Context, sel ast.SelectionSet, obj *models.SiteInfo) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, siteInfoImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("SiteInfo")
|
|
case "initialSetup":
|
|
out.Values[i] = ec._SiteInfo_initialSetup(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 subscriptionImplementors = []string{"Subscription"}
|
|
|
|
func (ec *executionContext) _Subscription(ctx context.Context, sel ast.SelectionSet) func() graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, subscriptionImplementors)
|
|
ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
|
|
Object: "Subscription",
|
|
})
|
|
if len(fields) != 1 {
|
|
ec.Errorf(ctx, "must subscribe to exactly one stream")
|
|
return nil
|
|
}
|
|
|
|
switch fields[0].Name {
|
|
case "notification":
|
|
return ec._Subscription_notification(ctx, fields[0])
|
|
default:
|
|
panic("unknown field " + strconv.Quote(fields[0].Name))
|
|
}
|
|
}
|
|
|
|
var userImplementors = []string{"User"}
|
|
|
|
func (ec *executionContext) _User(ctx context.Context, sel ast.SelectionSet, obj *models.User) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, userImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("User")
|
|
case "id":
|
|
out.Values[i] = ec._User_id(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "username":
|
|
out.Values[i] = ec._User_username(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "rootPath":
|
|
out.Values[i] = ec._User_rootPath(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "admin":
|
|
out.Values[i] = ec._User_admin(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.RequestContext, 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.RequestContext, 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.RequestContext, 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.RequestContext, 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.RequestContext, 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.RequestContext, 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) marshalNAlbum2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAlbum(ctx context.Context, sel ast.SelectionSet, v models.Album) graphql.Marshaler {
|
|
return ec._Album(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNAlbum2ᚕᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAlbumᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.Album) 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
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
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.marshalNAlbum2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAlbum(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNAlbum2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAlbum(ctx context.Context, sel ast.SelectionSet, v *models.Album) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._Album(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNAuthorizeResult2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAuthorizeResult(ctx context.Context, sel ast.SelectionSet, v models.AuthorizeResult) graphql.Marshaler {
|
|
return ec._AuthorizeResult(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNAuthorizeResult2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAuthorizeResult(ctx context.Context, sel ast.SelectionSet, v *models.AuthorizeResult) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._AuthorizeResult(ctx, sel, v)
|
|
}
|
|
|
|
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 !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
|
|
return graphql.UnmarshalInt(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
|
|
res := graphql.MarshalInt(v)
|
|
if res == graphql.Null {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
func (ec *executionContext) marshalNNotification2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐNotification(ctx context.Context, sel ast.SelectionSet, v models.Notification) graphql.Marshaler {
|
|
return ec._Notification(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNNotification2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐNotification(ctx context.Context, sel ast.SelectionSet, v *models.Notification) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._Notification(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNNotificationType2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐNotificationType(ctx context.Context, v interface{}) (models.NotificationType, error) {
|
|
var res models.NotificationType
|
|
return res, res.UnmarshalGQL(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNNotificationType2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐNotificationType(ctx context.Context, sel ast.SelectionSet, v models.NotificationType) graphql.Marshaler {
|
|
return v
|
|
}
|
|
|
|
func (ec *executionContext) marshalNPhoto2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhoto(ctx context.Context, sel ast.SelectionSet, v models.Photo) graphql.Marshaler {
|
|
return ec._Photo(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNPhoto2ᚕᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhotoᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.Photo) 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
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
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.marshalNPhoto2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhoto(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNPhoto2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhoto(ctx context.Context, sel ast.SelectionSet, v *models.Photo) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._Photo(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNPhotoDownload2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhotoDownload(ctx context.Context, sel ast.SelectionSet, v models.PhotoDownload) graphql.Marshaler {
|
|
return ec._PhotoDownload(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNPhotoDownload2ᚕᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhotoDownloadᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.PhotoDownload) 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
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
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.marshalNPhotoDownload2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhotoDownload(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNPhotoDownload2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhotoDownload(ctx context.Context, sel ast.SelectionSet, v *models.PhotoDownload) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._PhotoDownload(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNPhotoURL2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhotoURL(ctx context.Context, sel ast.SelectionSet, v models.PhotoURL) graphql.Marshaler {
|
|
return ec._PhotoURL(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNPhotoURL2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhotoURL(ctx context.Context, sel ast.SelectionSet, v *models.PhotoURL) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._PhotoURL(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNScannerResult2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐScannerResult(ctx context.Context, sel ast.SelectionSet, v models.ScannerResult) graphql.Marshaler {
|
|
return ec._ScannerResult(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNScannerResult2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐScannerResult(ctx context.Context, sel ast.SelectionSet, v *models.ScannerResult) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._ScannerResult(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNShareToken2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐShareToken(ctx context.Context, sel ast.SelectionSet, v models.ShareToken) graphql.Marshaler {
|
|
return ec._ShareToken(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNShareToken2ᚕᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐShareTokenᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.ShareToken) 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
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
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.marshalNShareToken2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐShareToken(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNShareToken2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐShareToken(ctx context.Context, sel ast.SelectionSet, v *models.ShareToken) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._ShareToken(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNSiteInfo2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐSiteInfo(ctx context.Context, sel ast.SelectionSet, v models.SiteInfo) graphql.Marshaler {
|
|
return ec._SiteInfo(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNSiteInfo2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐSiteInfo(ctx context.Context, sel ast.SelectionSet, v *models.SiteInfo) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._SiteInfo(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 !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
func (ec *executionContext) marshalNUser2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐUser(ctx context.Context, sel ast.SelectionSet, v models.User) graphql.Marshaler {
|
|
return ec._User(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNUser2ᚕᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐUserᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.User) 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
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
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.marshalNUser2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐUser(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNUser2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐUser(ctx context.Context, sel ast.SelectionSet, v *models.User) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._User(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
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
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 !ec.HasError(graphql.GetResolverContext(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
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
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
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
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
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
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 !ec.HasError(graphql.GetResolverContext(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 !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
func (ec *executionContext) marshalOAlbum2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAlbum(ctx context.Context, sel ast.SelectionSet, v models.Album) graphql.Marshaler {
|
|
return ec._Album(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOAlbum2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAlbum(ctx context.Context, sel ast.SelectionSet, v *models.Album) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec._Album(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOAuthorizeResult2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAuthorizeResult(ctx context.Context, sel ast.SelectionSet, v models.AuthorizeResult) graphql.Marshaler {
|
|
return ec._AuthorizeResult(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOAuthorizeResult2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐAuthorizeResult(ctx context.Context, sel ast.SelectionSet, v *models.AuthorizeResult) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec._AuthorizeResult(ctx, sel, v)
|
|
}
|
|
|
|
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) unmarshalOFilter2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐFilter(ctx context.Context, v interface{}) (models.Filter, error) {
|
|
return ec.unmarshalInputFilter(ctx, v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOFilter2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐFilter(ctx context.Context, v interface{}) (*models.Filter, error) {
|
|
if v == nil {
|
|
return nil, nil
|
|
}
|
|
res, err := ec.unmarshalOFilter2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐFilter(ctx, v)
|
|
return &res, err
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOFloat2float64(ctx context.Context, v interface{}) (float64, error) {
|
|
return graphql.UnmarshalFloat(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOFloat2float64(ctx context.Context, sel ast.SelectionSet, v float64) graphql.Marshaler {
|
|
return graphql.MarshalFloat(v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOFloat2ᚖfloat64(ctx context.Context, v interface{}) (*float64, error) {
|
|
if v == nil {
|
|
return nil, nil
|
|
}
|
|
res, err := ec.unmarshalOFloat2float64(ctx, v)
|
|
return &res, err
|
|
}
|
|
|
|
func (ec *executionContext) marshalOFloat2ᚖfloat64(ctx context.Context, sel ast.SelectionSet, v *float64) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec.marshalOFloat2float64(ctx, sel, *v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
|
|
return graphql.UnmarshalInt(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
|
|
return graphql.MarshalInt(v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
|
|
if v == nil {
|
|
return nil, nil
|
|
}
|
|
res, err := ec.unmarshalOInt2int(ctx, v)
|
|
return &res, err
|
|
}
|
|
|
|
func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec.marshalOInt2int(ctx, sel, *v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOOrderDirection2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐOrderDirection(ctx context.Context, v interface{}) (models.OrderDirection, error) {
|
|
var res models.OrderDirection
|
|
return res, res.UnmarshalGQL(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOOrderDirection2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐOrderDirection(ctx context.Context, sel ast.SelectionSet, v models.OrderDirection) graphql.Marshaler {
|
|
return v
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOOrderDirection2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐOrderDirection(ctx context.Context, v interface{}) (*models.OrderDirection, error) {
|
|
if v == nil {
|
|
return nil, nil
|
|
}
|
|
res, err := ec.unmarshalOOrderDirection2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐOrderDirection(ctx, v)
|
|
return &res, err
|
|
}
|
|
|
|
func (ec *executionContext) marshalOOrderDirection2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐOrderDirection(ctx context.Context, sel ast.SelectionSet, v *models.OrderDirection) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return v
|
|
}
|
|
|
|
func (ec *executionContext) marshalOPhoto2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhoto(ctx context.Context, sel ast.SelectionSet, v models.Photo) graphql.Marshaler {
|
|
return ec._Photo(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOPhoto2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhoto(ctx context.Context, sel ast.SelectionSet, v *models.Photo) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec._Photo(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOPhotoEXIF2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhotoExif(ctx context.Context, sel ast.SelectionSet, v models.PhotoExif) graphql.Marshaler {
|
|
return ec._PhotoEXIF(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOPhotoEXIF2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐPhotoExif(ctx context.Context, sel ast.SelectionSet, v *models.PhotoExif) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec._PhotoEXIF(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOShareToken2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐShareToken(ctx context.Context, sel ast.SelectionSet, v models.ShareToken) graphql.Marshaler {
|
|
return ec._ShareToken(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOShareToken2ᚕᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐShareToken(ctx context.Context, sel ast.SelectionSet, v []*models.ShareToken) 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
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
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.marshalOShareToken2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐShareToken(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalOShareToken2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐShareToken(ctx context.Context, sel ast.SelectionSet, v *models.ShareToken) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec._ShareToken(ctx, sel, v)
|
|
}
|
|
|
|
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) unmarshalOTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
|
|
return graphql.UnmarshalTime(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
|
|
return graphql.MarshalTime(v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
|
|
if v == nil {
|
|
return nil, nil
|
|
}
|
|
res, err := ec.unmarshalOTime2timeᚐTime(ctx, v)
|
|
return &res, err
|
|
}
|
|
|
|
func (ec *executionContext) marshalOTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec.marshalOTime2timeᚐTime(ctx, sel, *v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOUser2githubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐUser(ctx context.Context, sel ast.SelectionSet, v models.User) graphql.Marshaler {
|
|
return ec._User(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOUser2ᚖgithubᚗcomᚋviktorstrateᚋphotoviewᚋapiᚋgraphqlᚋmodelsᚐUser(ctx context.Context, sel ast.SelectionSet, v *models.User) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec._User(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
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
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
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
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
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
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
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
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 *****************************
|