nkode-core/api/nkode_api.go

package api

import (
	"fmt"
	"git.infra.nkode.tech/dkelly/nkode-core/config"
	"git.infra.nkode.tech/dkelly/nkode-core/email"
	"git.infra.nkode.tech/dkelly/nkode-core/entities"
	"git.infra.nkode.tech/dkelly/nkode-core/repository"
	"git.infra.nkode.tech/dkelly/nkode-core/security"
	"github.com/google/uuid"
	"github.com/patrickmn/go-cache"
	"log"
	"os"
	"time"
)

const (
	sessionExpiration      = 5 * time.Minute
	sessionCleanupInterval = 10 * time.Minute
)

type NKodeAPI struct {
	repo               repository.CustomerUserRepository
	signupSessionCache *cache.Cache
	emailQueue         *email.Queue
	forgotNkodeCache   mem_cache.ForgotNKodeCache
}

func NewNKodeAPI(repo repository.CustomerUserRepository, queue *email.Queue) NKodeAPI {
	return NKodeAPI{
		repo:               repo,
		emailQueue:         queue,
		signupSessionCache: cache.New(sessionExpiration, sessionCleanupInterval),
		forgotNkodeCache:   mem_cache.NewForgotNKodeCache(),
	}
}

func (n *NKodeAPI) CreateNewCustomer(nkodePolicy entities.NKodePolicy) (*entities.CustomerId, error) {
	newCustomer, err := entities.NewCustomer(nkodePolicy)
	if err != nil {
		return nil, err
	}
	err = n.repo.CreateCustomer(*newCustomer)

	if err != nil {
		return nil, err
	}
	return &newCustomer.Id, nil
}

func (n *NKodeAPI) CreateCustomerWithID(id entities.CustomerId, nkodePolicy entities.NKodePolicy) error {
	newCustomer, err := entities.NewCustomer(nkodePolicy)
	if err != nil {
		return err
	}
	newCustomer.Id = id
	if err = n.repo.CreateCustomer(*newCustomer); err != nil {
		return err
	}
	return nil
}

func (n *NKodeAPI) GenerateSignupResetInterface(userEmail entities.UserEmail, customerId entities.CustomerId, kp entities.KeypadDimension, reset bool) (*entities.SignupResetInterface, error) {
	user, err := n.repo.GetUser(userEmail, customerId)
	if err != nil {
		return nil, err
	}
	if user != nil && !reset {
		log.Printf("user %s already exists", string(userEmail))
		return nil, config.ErrUserAlreadyExists
	}
	svgIdxInterface, err := n.repo.RandomSvgIdxInterface(kp)
	if err != nil {
		return nil, err
	}
	signupSession, err := entities.NewSignupResetSession(userEmail, kp, customerId, svgIdxInterface, reset)
	if err != nil {
		return nil, err
	}
	if err := n.signupSessionCache.Add(signupSession.Id.String(), *signupSession, sessionExpiration); err != nil {
		return nil, err
	}
	svgInterface, err := n.repo.GetSvgStringInterface(signupSession.LoginUserInterface.SvgId)
	if err != nil {
		return nil, err
	}
	resp := entities.SignupResetInterface{
		UserIdxInterface: signupSession.SetIdxInterface,
		SvgInterface:     svgInterface,
		SessionId:        uuid.UUID(signupSession.Id).String(),
		Colors:           signupSession.Colors,
	}
	return &resp, nil
}

func (n *NKodeAPI) SetNKode(customerId entities.CustomerId, sessionId entities.SessionId, keySelection entities.KeySelection) (entities.IdxInterface, error) {
	_, err := n.repo.GetCustomer(customerId)

	if err != nil {
		return nil, err
	}
	session, exists := n.signupSessionCache.Get(sessionId.String())
	if !exists {
		log.Printf("session id does not exist %s", sessionId)
		return nil, config.ErrSignupSessionDNE
	}
	userSession, ok := session.(entities.UserSignSession)
	if !ok {
		// handle the case where the type assertion fails
		return nil, config.ErrSignupSessionDNE
	}
	confirmInterface, err := userSession.SetUserNKode(keySelection)
	if err != nil {
		return nil, err
	}
	n.signupSessionCache.Set(sessionId.String(), userSession, sessionExpiration)
	return confirmInterface, nil
}

func (n *NKodeAPI) ConfirmNKode(customerId entities.CustomerId, sessionId entities.SessionId, keySelection entities.KeySelection) error {
	session, exists := n.signupSessionCache.Get(sessionId.String())
	if !exists {
		log.Printf("session id does not exist %s", sessionId)
		return config.ErrSignupSessionDNE
	}
	userSession, ok := session.(entities.UserSignSession)
	if !ok {
		// handle the case where the type assertion fails
		return config.ErrSignupSessionDNE
	}
	customer, err := n.repo.GetCustomer(customerId)
	if err != nil {
		return err
	}
	passcode, err := userSession.DeducePasscode(keySelection)
	if err != nil {
		return err
	}
	if err = customer.IsValidNKode(userSession.Kp, passcode); err != nil {
		return err
	}
	user, err := entities.NewUser(*customer, string(userSession.UserEmail), passcode, userSession.LoginUserInterface, userSession.Kp)
	if err != nil {
		return err
	}
	if userSession.Reset {
		err = n.repo.UpdateUserNKode(*user)
	} else {
		err = n.repo.WriteNewUser(*user)
	}
	n.signupSessionCache.Delete(userSession.Id.String())
	return err
}

func (n *NKodeAPI) GetLoginInterface(userEmail entities.UserEmail, customerId entities.CustomerId) (*entities.LoginInterface, error) {
	user, err := n.repo.GetUser(userEmail, customerId)
	if err != nil {
		return nil, err
	}
	if user == nil {
		log.Printf("user %s for customer %s dne", userEmail, customerId)
		return nil, config.ErrUserForCustomerDNE
	}
	svgInterface, err := n.repo.GetSvgStringInterface(user.Interface.SvgId)
	if err != nil {
		return nil, err
	}
	resp := entities.LoginInterface{
		UserIdxInterface: user.Interface.IdxInterface,
		SvgInterface:     svgInterface,
		NumbOfKeys:       user.Kp.NumbOfKeys,
		AttrsPerKey:      user.Kp.AttrsPerKey,
		Colors:           entities.SetColors,
	}
	return &resp, nil
}

func (n *NKodeAPI) Login(customerId entities.CustomerId, userEmail entities.UserEmail, keySelection entities.KeySelection) (*security.AuthenticationTokens, error) {
	customer, err := n.repo.GetCustomer(customerId)
	if err != nil {
		return nil, err
	}
	user, err := n.repo.GetUser(userEmail, customerId)
	if err != nil {
		return nil, err
	}
	if user == nil {
		log.Printf("user %s for customer %s dne", userEmail, customerId)
		return nil, config.ErrUserForCustomerDNE
	}
	passcode, err := entities.ValidKeyEntry(*user, *customer, keySelection)
	if err != nil {
		return nil, err
	}

	if user.Renew {
		err = n.repo.RefreshUserPasscode(*user, passcode, customer.Attributes)
		if err != nil {
			return nil, err
		}
	}

	jwtToken, err := security.NewAuthenticationTokens(string(user.Email), uuid.UUID(customerId))
	if err != nil {
		return nil, err
	}
	if err = n.repo.UpdateUserRefreshToken(user.Id, jwtToken.RefreshToken); err != nil {
		return nil, err
	}
	if err = user.Interface.LoginShuffle(); err != nil {
		return nil, err
	}
	if err = n.repo.UpdateUserInterface(user.Id, user.Interface); err != nil {
		return nil, err
	}
	return &jwtToken, nil
}

func (n *NKodeAPI) RenewAttributes(customerId entities.CustomerId) error {
	return n.repo.Renew(customerId)
}

func (n *NKodeAPI) RandomSvgInterface() ([]string, error) {
	return n.repo.RandomSvgInterface(entities.KeypadMax)
}

func (n *NKodeAPI) RefreshToken(userEmail entities.UserEmail, customerId entities.CustomerId, refreshToken string) (string, error) {
	user, err := n.repo.GetUser(userEmail, customerId)
	if err != nil {
		return "", err
	}
	if user == nil {
		log.Printf("user %s for customer %s dne", userEmail, customerId)
		return "", config.ErrUserForCustomerDNE
	}
	if user.RefreshToken != refreshToken {
		return "", config.ErrRefreshTokenInvalid
	}
	refreshClaims, err := security.ParseRegisteredClaimToken(refreshToken)
	if err != nil {
		return "", err
	}
	if err = security.ClaimExpired(*refreshClaims); err != nil {
		return "", err
	}
	newAccessClaims := security.NewAccessClaim(string(userEmail), uuid.UUID(customerId))
	return security.EncodeAndSignClaims(newAccessClaims)
}

func (n *NKodeAPI) ForgotNKode(userEmail entities.UserEmail, customerId entities.CustomerId) error {
	user, err := n.repo.GetUser(userEmail, customerId)
	if err != nil {
		return fmt.Errorf("error getting user in rest nkode %v", err)
	}

	if user == nil {
		return nil
	}

	nkodeResetJwt, err := security.ResetNKodeToken(string(userEmail), uuid.UUID(customerId).String())
	if err != nil {
		return err
	}
	frontendHost := os.Getenv("FRONTEND_HOST")
	if frontendHost == "" {
		frontendHost = config.FrontendHost
	}
	htmlBody := fmt.Sprintf("<h1>Hello!</h1><p>Click the link to reset your nKode.</p><a href=\"%s?token=%s\">Reset nKode</a>", frontendHost, nkodeResetJwt)
	email := email.Email{
		Sender:    "no-reply@nkode.tech",
		Recipient: string(userEmail),
		Subject:   "nKode Reset",
		Content:   htmlBody,
	}
	n.emailQueue.AddEmail(email)
	n.forgotNkodeCache.Set(userEmail, customerId)
	return nil
}

func (n *NKodeAPI) Signout(userEmail entities.UserEmail, customerId entities.CustomerId) error {
	user, err := n.repo.GetUser(userEmail, customerId)
	if err != nil {
		return err
	}
	if user == nil {
		log.Printf("user %s for customer %s dne", userEmail, customerId)
		return config.ErrUserForCustomerDNE
	}
	if err = n.repo.UpdateUserRefreshToken(user.Id, ""); err != nil {
		return err
	}
	return nil
}