api/resolver/story.go

package resolver

import (
	"context"
	"time"

	"git.aiterp.net/rpdata/api/model/story"
)

// StoryResolver for the Story graphql type
type StoryResolver struct{ S story.Story }

// StoryArgs is args for story query
type StoryArgs struct {
	ID string
}

// Story implements the story query
func (r *QueryResolver) Story(ctx context.Context, args *StoryArgs) (*StoryResolver, error) {
	story, err := story.FindID(args.ID)
	if err != nil {
		return nil, err
	}

	return &StoryResolver{S: story}, nil
}

// StoriesArg is args for stories query
type StoriesArg struct {
	Input *StoriesInput
}

// StoriesInput resolves the TagInput input
type StoriesInput struct {
	Author                *string
	Tags                  *[]TagInput
	EarliestFictionalDate *string
	LatestFictionalDate   *string
	Limit                 *int32
}

// Stories implements the stories query
func (r *QueryResolver) Stories(ctx context.Context, args *StoriesArg) ([]*StoryResolver, error) {
	author := ""
	if args.Input.Author != nil {
		author = *args.Input.Author
	}

	tags := make([]story.Tag, 0, 8)
	if args.Input.Tags != nil {
		for _, tagInput := range *args.Input.Tags {
			tags = append(tags, story.Tag{
				Kind: tagInput.Kind,
				Name: tagInput.Name,
			})
		}
	}

	earliest := time.Time{}
	err := error(nil)
	if args.Input.EarliestFictionalDate != nil {
		earliest, err = time.Parse(time.RFC3339Nano, *args.Input.EarliestFictionalDate)
		if err != nil {
			return nil, err
		}
	}

	latest := time.Time{}
	if args.Input.LatestFictionalDate != nil {
		latest, err = time.Parse(time.RFC3339Nano, *args.Input.LatestFictionalDate)
		if err != nil {
			return nil, err
		}
	}

	limit := 30
	if args.Input.Limit != nil {
		limit = int(*args.Input.Limit)
	}

	stories, err := story.List(author, tags, earliest, latest, limit)
	if err != nil {
		return nil, err
	}

	resolvers := make([]*StoryResolver, len(stories))
	for i, story := range stories {
		resolvers[i] = &StoryResolver{S: story}
	}

	return resolvers, nil
}

// ID resolves Story.id
func (r *StoryResolver) ID() string {
	return r.S.ID
}

// Author resolves Story.author
func (r *StoryResolver) Author() string {
	return r.S.Author
}

// Name resolves Story.name
func (r *StoryResolver) Name() string {
	return r.S.Name
}

// Category resolves Story.category
func (r *StoryResolver) Category() string {
	return r.S.Category
}

// Open resolves Story.open
func (r *StoryResolver) Open() bool {
	return r.S.Open
}

// Listed resolves Story.listed
func (r *StoryResolver) Listed() bool {
	return r.S.Listed
}

// Tags resolves Story.tags
func (r *StoryResolver) Tags() []*TagResolver {
	resolvers := make([]*TagResolver, len(r.S.Tags))
	for i, tag := range r.S.Tags {
		resolvers[i] = &TagResolver{T: tag}
	}

	return resolvers
}

// Chapters resolves Story.chapters
func (r *StoryResolver) Chapters() ([]*ChapterResolver, error) {
	chapters, err := r.S.Chapters()
	if err != nil {
		return nil, err
	}

	resolvers := make([]*ChapterResolver, len(chapters))
	for i, chapter := range chapters {
		resolvers[i] = &ChapterResolver{C: chapter}
	}

	return resolvers, nil
}

// CreatedDate resolves Story.createdDate
func (r *StoryResolver) CreatedDate() string {
	return r.S.CreatedDate.Format(time.RFC3339Nano)
}

// FictionalDate resolves Story.fictionalDate
func (r *StoryResolver) FictionalDate() string {
	return r.S.FictionalDate.Format(time.RFC3339Nano)
}

// UpdatedDate resolves Story.updatedDate
func (r *StoryResolver) UpdatedDate() string {
	return r.S.UpdatedDate.Format(time.RFC3339Nano)
}