api/resolver/log.go

package resolver

import (
	"context"
	"errors"
	"time"

	"git.aiterp.net/rpdata/api/loader"
	"git.aiterp.net/rpdata/api/model/change"
	"git.aiterp.net/rpdata/api/resolver/types"

	"git.aiterp.net/rpdata/api/internal/session"
	"git.aiterp.net/rpdata/api/model/log"
)

// LogResolver for the Log graphql type
type LogResolver struct{ L log.Log }

// LogArgs is an arg
type LogArgs struct {
	ID *string
}

// LogPostArgs is an arg
type LogPostArgs struct {
	Kinds *[]string
}

// Log finds log
func (r *QueryResolver) Log(ctx context.Context, args *LogArgs) (*LogResolver, error) {
	var l log.Log
	var err error

	switch {
	case args.ID != nil:
		l, err = log.FindID(*args.ID)
	default:
		err = ErrCannotResolve
	}

	if err != nil {
		return nil, err
	}

	return &LogResolver{L: l}, nil
}

// LogQueryArgs is args for the logs query
type LogQueryArgs struct {
	Filter *struct {
		Search     *string
		Characters *[]string
		Channels   *[]string
		Events     *[]string
		Open       *bool
		Limit      *int32
	}
}

// Logs resolves the logs query
func (r *QueryResolver) Logs(ctx context.Context, args *LogQueryArgs) ([]*LogResolver, error) {
	var logs []log.Log
	var err error

	filter := args.Filter

	if filter != nil {
		limit := 100
		search := ""

		if filter.Search != nil {
			search = *filter.Search
			limit = 0
		}

		channels := []string(nil)
		if filter.Channels != nil {
			channels = *filter.Channels
			limit = 0
		}

		characters := []string(nil)
		if filter.Characters != nil {
			characters = *filter.Characters
			limit = 0
		}

		events := []string(nil)
		if filter.Events != nil {
			events = *filter.Events
			limit = 0
		}

		if filter.Limit != nil {
			limit = int(*filter.Limit)
		}

		open := filter.Open != nil && *filter.Open == true

		logs, err = log.ListSearch(search, channels, characters, events, open, limit)
		if err != nil {
			return nil, err
		}
	} else {
		logs, err = log.List(100)
		if err != nil {
			return nil, err
		}
	}

	resolvers := make([]*LogResolver, len(logs))
	for i := range logs {
		resolvers[i] = &LogResolver{L: logs[i]}
	}

	return resolvers, nil
}

// LogAddArgs is args for the addLog mutation
type LogAddArgs struct {
	Input *struct {
		Date        string
		Channel     string
		Title       *string
		Open        *bool
		Event       *string
		Description *string
	}
}

// AddLog resolves the addLog mutation
func (r *MutationResolver) AddLog(ctx context.Context, args *LogAddArgs) (*LogResolver, error) {
	input := args.Input

	user := session.FromContext(ctx).User()
	if user == nil || !user.Permitted("log.add") {
		return nil, ErrUnauthorized
	}

	date, err := time.Parse(time.RFC3339Nano, args.Input.Date)
	if err != nil {
		return nil, err
	}

	title := ""
	if input.Title != nil {
		title = *input.Title
	}

	event := ""
	if input.Event != nil {
		event = *input.Event
	}

	description := ""
	if input.Description != nil {
		description = *input.Description
	}

	open := input.Open != nil && *input.Open == true

	log, err := log.New(date, input.Channel, title, event, description, open)
	if err != nil {
		return nil, err
	}

	go change.Submit("Log", "add", user.ID, log.ID, map[string]interface{}{
		"channel":     log.Channel,
		"title":       log.Title,
		"event":       log.Event,
		"description": log.Description,
		"open":        log.Open,
	})

	return &LogResolver{L: log}, nil
}

// LogEditArgs is an input
type LogEditArgs struct {
	Input *struct {
		ID          string
		Title       *string
		Event       *string
		Description *string
		Open        *bool
	}
}

// EditLog resolves the editLog mutation
func (r *MutationResolver) EditLog(ctx context.Context, args *LogEditArgs) (*LogResolver, error) {
	input := args.Input

	user := session.FromContext(ctx).User()
	if user == nil || !user.Permitted("log.edit") {
		return nil, ErrUnauthorized
	}

	log, err := log.FindID(input.ID)
	if err != nil {
		return nil, err
	}

	err = log.Edit(input.Title, input.Event, input.Description, input.Open)
	if err != nil {
		return nil, err
	}

	go change.Submit("Log", "edit", user.ID, log.ID, map[string]interface{}{
		"channel":     log.Channel,
		"title":       input.Title,
		"event":       input.Event,
		"description": input.Description,
		"open":        input.Open,
	})

	return &LogResolver{L: log}, nil
}

// RemoveLog resolves the removeLog mutation
func (r *MutationResolver) RemoveLog(ctx context.Context, args *struct{ ID string }) (*LogResolver, error) {
	user := session.FromContext(ctx).User()
	if user == nil || !user.Permitted("log.remove") {
		return nil, ErrUnauthorized
	}

	log, err := log.FindID(args.ID)
	if err != nil {
		return nil, err
	}

	err = log.Remove()
	if err != nil {
		return nil, err
	}

	go change.Submit("Log", "remove", user.ID, log.ID, nil)

	return &LogResolver{L: log}, nil
}

// ID resolves Log.id
func (r *LogResolver) ID() string {
	return r.L.ID
}

// ShortID resolves Log.shortId
func (r *LogResolver) ShortID() string {
	return r.L.ShortID
}

// Date resolves Log.date
func (r *LogResolver) Date() string {
	return r.L.Date.Format(time.RFC3339Nano)
}

// ChannelName resolves Log.channelName
func (r *LogResolver) ChannelName() string {
	return r.L.Channel
}

// Channel resolves Log.channe
func (r *LogResolver) Channel(ctx context.Context) (*types.ChannelResolver, error) {
	loader := loader.FromContext(ctx)
	if loader == nil {
		return nil, errors.New("no loader")
	}

	channel, err := loader.Channel("name", r.L.Channel)
	if err != nil {
		return nil, err
	}

	return &types.ChannelResolver{C: channel}, nil
}

// Title resolves Log.title
func (r *LogResolver) Title() string {
	return r.L.Title
}

// Event resolves Log.event
func (r *LogResolver) Event() string {
	return r.L.Event
}

// Description resolves Log.description
func (r *LogResolver) Description() string {
	return r.L.Description
}

// Open resolves Log.open
func (r *LogResolver) Open() bool {
	return r.L.Open
}

// Characters resolves Log.characters
func (r *LogResolver) Characters(ctx context.Context) ([]*types.CharacterResolver, error) {
	loader := loader.FromContext(ctx)
	if loader == nil {
		return nil, errors.New("no loader")
	}

	chars, err := loader.Characters("id", r.L.CharacterIDs...)
	if err != nil {
		return nil, err
	}

	resolvers := make([]*types.CharacterResolver, 0, len(chars))
	for i := range chars {
		if chars[i].ID == "" {
			continue
		}

		resolvers = append(resolvers, &types.CharacterResolver{C: chars[i]})
	}

	return resolvers, nil
}

// Posts resolves Log.posts
func (r *LogResolver) Posts(ctx context.Context, args *LogPostArgs) ([]*PostResolver, error) {
	var kinds []string
	if args.Kinds != nil {
		kinds = *args.Kinds
	}

	posts, err := r.L.Posts(kinds...)
	if err != nil {
		return nil, err
	}

	resolvers := make([]*PostResolver, len(posts))
	for i := range posts {
		resolvers[i] = &PostResolver{posts[i]}
	}

	return resolvers, nil
}