imagini/graph/schema.resolvers.go

package graph

// This file will be automatically regenerated based on the schema, any resolver implementations
// will be copied through when generating and any unknown code will be moved to the end.

import (
	"context"
	"fmt"
	"net/http"
	"strings"

	"github.com/google/uuid"
	"reichard.io/imagini/graph/generated"
	"reichard.io/imagini/graph/model"
)

func (r *mutationResolver) CreateMediaItem(ctx context.Context, input model.NewMediaItem) (*model.MediaItem, error) {
	panic(fmt.Errorf("not implemented"))
}

func (r *mutationResolver) CreateDevice(ctx context.Context, input model.NewDevice) (*model.Device, error) {
	panic(fmt.Errorf("not implemented"))
}

func (r *mutationResolver) CreateAlbum(ctx context.Context, input model.NewAlbum) (*model.Album, error) {
	panic(fmt.Errorf("not implemented"))
}

func (r *mutationResolver) CreateTag(ctx context.Context, input model.NewTag) (*model.Tag, error) {
	panic(fmt.Errorf("not implemented"))
}

func (r *mutationResolver) CreateUser(ctx context.Context, input model.NewUser) (*model.User, error) {
	user := &model.User{
		Email:     input.Email,
		Username:  input.Username,
		FirstName: input.FirstName,
		LastName:  input.LastName,
		Role:      input.Role,
		AuthType:  input.AuthType,
		Password:  input.Password,
	}

	err := r.DB.CreateUser(user)
	if err != nil {
		return nil, err
	}

	return user, nil
}

func (r *queryResolver) Login(ctx context.Context, user string, password string, deviceID *string) (*model.AuthResponse, error) {
	// Set Cookie From Context
	authContext := ctx.Value("auth").(*model.AuthContext)
	resp := authContext.AuthResponse
	req := authContext.AuthRequest

	// Do Login
	foundUser, success := r.Auth.AuthenticateUser(user, password)
	if !success {
		return &model.AuthResponse{Result: model.AuthResultFailure}, nil
	}

	// Upsert Device
	foundDevice := model.Device{}
	if deviceID != nil {
		parsedDeviceID, err := uuid.Parse(*deviceID)
		if err != nil {
			return &model.AuthResponse{Result: model.AuthResultFailure}, nil
		}
		foundDevice.ID = parsedDeviceID.String()
		count, err := r.DB.Device(&foundDevice)
		if count != 1 || err != nil {
			return &model.AuthResponse{Result: model.AuthResultFailure}, nil
		}
	} else {
		foundDevice.Type = deriveDeviceType(req)
		foundDevice.UserID = foundUser.ID
		// TODO: foundDevice.User = &foundUser
		err := r.DB.CreateDevice(&foundDevice)
		if err != nil {
			return &model.AuthResponse{Result: model.AuthResultFailure}, nil
		}
	}

	// Create Tokens
	accessToken, err := r.Auth.CreateJWTAccessToken(foundUser, foundDevice)
	if err != nil {
		return &model.AuthResponse{Result: model.AuthResultFailure}, nil
	}
	refreshToken, err := r.Auth.CreateJWTRefreshToken(foundUser, foundDevice)
	if err != nil {
		return &model.AuthResponse{Result: model.AuthResultFailure}, nil
	}

	// Set appropriate cookies
	accessCookie := http.Cookie{Name: "AccessToken", Value: accessToken, Path: "/", HttpOnly: true}
	refreshCookie := http.Cookie{Name: "RefreshToken", Value: refreshToken, Path: "/", HttpOnly: true}
	http.SetCookie(*resp, &accessCookie)
	http.SetCookie(*resp, &refreshCookie)

	// TODO: Prob bandaid
	foundDevice.User = &foundUser
	return &model.AuthResponse{Result: model.AuthResultSuccess, Device: &foundDevice}, nil
}

func (r *queryResolver) Logout(ctx context.Context) (*model.AuthResponse, error) {
	// panic(fmt.Errorf("not implemented"))
	return &model.AuthResponse{Result: model.AuthResultSuccess}, nil
}

func (r *queryResolver) MediaItem(ctx context.Context, id string) (*model.MediaItem, error) {
	panic(fmt.Errorf("not implemented"))
}

func (r *queryResolver) Device(ctx context.Context, id string) (*model.Device, error) {
	panic(fmt.Errorf("not implemented"))
}

func (r *queryResolver) Album(ctx context.Context, id string) (*model.Album, error) {
	panic(fmt.Errorf("not implemented"))
}

func (r *queryResolver) User(ctx context.Context, id string) (*model.User, error) {
	panic(fmt.Errorf("not implemented"))
}

func (r *queryResolver) Tag(ctx context.Context, id string) (*model.Tag, error) {
	panic(fmt.Errorf("not implemented"))
}

func (r *queryResolver) Me(ctx context.Context) (*model.User, error) {
	panic(fmt.Errorf("not implemented"))
}

func (r *queryResolver) MediaItems(ctx context.Context, filter *model.MediaItemFilter, count *int, page *int) (*model.MediaItemResponse, error) {
	panic(fmt.Errorf("not implemented"))
}

func (r *queryResolver) Devices(ctx context.Context, filter *model.DeviceFilter, count *int, page *int) (*model.DeviceResponse, error) {
	panic(fmt.Errorf("not implemented"))
}

func (r *queryResolver) Albums(ctx context.Context, filter *model.AlbumFilter, count *int, page *int) (*model.AlbumResponse, error) {
	panic(fmt.Errorf("not implemented"))
}

func (r *queryResolver) Tags(ctx context.Context, filter *model.TagFilter, count *int, page *int) (*model.TagResponse, error) {
	panic(fmt.Errorf("not implemented"))
}

func (r *queryResolver) Users(ctx context.Context, filter *model.UserFilter, count *int, page *int) (*model.UserResponse, error) {
	resp, totalCount, err := r.DB.Users()
	if err != nil {
		panic(fmt.Errorf("DB Error"))
	}
	return &model.UserResponse{
		Data: resp,
		PageInfo: &model.PageInfo{
			Count: int(totalCount),
			Page:  0,
			Total: int(totalCount),
		},
	}, nil
}

// Mutation returns generated.MutationResolver implementation.
func (r *Resolver) Mutation() generated.MutationResolver { return &mutationResolver{r} }

// Query returns generated.QueryResolver implementation.
func (r *Resolver) Query() generated.QueryResolver { return &queryResolver{r} }

type mutationResolver struct{ *Resolver }
type queryResolver struct{ *Resolver }

// !!! WARNING !!!
// The code below was going to be deleted when updating resolvers. It has been copied here so you have
// one last chance to move it out of harms way if you want. There are two reasons this happens:
//  - When renaming or deleting a resolver the old code will be put in here. You can safely delete
//    it when you're done.
//  - You have helper methods in this file. Move them out to keep these resolver files clean.
func deriveDeviceType(r *http.Request) model.DeviceType {
	userAgent := strings.ToLower(r.Header.Get("User-Agent"))
	if strings.Contains(userAgent, "ios-imagini") {
		return model.DeviceTypeIOs
	} else if strings.Contains(userAgent, "android-imagini") {
		return model.DeviceTypeAndroid
	} else if strings.Contains(userAgent, "chrome") {
		return model.DeviceTypeChrome
	} else if strings.Contains(userAgent, "firefox") {
		return model.DeviceTypeFirefox
	} else if strings.Contains(userAgent, "msie") {
		return model.DeviceTypeInternetExplorer
	} else if strings.Contains(userAgent, "edge") {
		return model.DeviceTypeEdge
	} else if strings.Contains(userAgent, "safari") {
		return model.DeviceTypeSafari
	}
	return model.DeviceTypeUnknown
}