go-nkode/core/nkode/nkode_in_memory.go

package nkode

import (
	"errors"
	"fmt"
	m "go-nkode/core/model"
)

type NKodeInMemory struct {
	Customers      map[m.CustomerId]Customer
	SignupSessions map[m.SessionId]UserSignSession
}

func NewNKodeInMemory() NKodeInMemory {
	return NKodeInMemory{
		Customers:      make(map[m.CustomerId]Customer),
		SignupSessions: make(map[m.SessionId]UserSignSession),
	}
}

func (n *NKodeInMemory) CreateNewCustomer(nkodePolicy m.NKodePolicy) (*m.CustomerId, error) {
	newCustomer, err := NewCustomer(nkodePolicy)
	if err != nil {
		return nil, err
	}
	n.Customers[newCustomer.CustomerId] = *newCustomer
	return &newCustomer.CustomerId, nil
}

func (n *NKodeInMemory) GenerateSignupInterface(customerId m.CustomerId, kp m.KeypadDimension) (*m.GenerateSignupInterfaceResp, error) {
	customer, exists := n.Customers[customerId]
	if !exists {
		return nil, errors.New(fmt.Sprintf("customer doesnt exists: %s", customerId))
	}

	signupSession, err := NewSignupSession(kp, customer.CustomerId)
	if err != nil {
		return nil, err
	}
	n.SignupSessions[signupSession.SessionId] = *signupSession
	resp := m.GenerateSignupInterfaceResp{
		UserInterface: signupSession.SetIdxInterface,
		SessionId:     signupSession.SessionId,
	}
	return &resp, nil
}

func (n *NKodeInMemory) SetNKode(username m.Username, customerId m.CustomerId, sessionId m.SessionId, keySelection m.KeySelection) (m.IdxInterface, error) {
	_, exists := n.Customers[customerId]
	if !exists {
		return nil, errors.New(fmt.Sprintf("set nkode customer id does not exist %s", customerId))
	}

	session, exists := n.SignupSessions[sessionId]
	if !exists {
		return nil, errors.New(fmt.Sprintf("session id does not exist %s", sessionId))
	}
	confirmInterface, err := session.SetUserNKode(username, keySelection)
	if err != nil {
		return nil, err
	}
	n.SignupSessions[sessionId] = session
	return confirmInterface, nil
}

func (n *NKodeInMemory) ConfirmNKode(customerId m.CustomerId, sessionId m.SessionId, keySelection m.KeySelection) error {
	session, exists := n.SignupSessions[sessionId]
	if !exists {
		return errors.New(fmt.Sprintf("session id does not exist %s", sessionId))
	}
	customer, exists := n.Customers[customerId]
	passcode, err := session.DeducePasscode(keySelection)
	if err != nil {
		return err
	}
	err = customer.IsValidNKode(session.Kp, passcode)
	if err != nil {
		return err
	}
	err = customer.AddNewUser(session.Username, passcode, session.LoginUserInterface, session.Kp)
	if err != nil {
		return err
	}
	delete(n.SignupSessions, session.SessionId)
	n.Customers[customerId] = customer
	return nil
}

func (n *NKodeInMemory) GetLoginInterface(username m.Username, customerId m.CustomerId) (m.IdxInterface, error) {
	err := n.customerUserExists(username, customerId)
	if err != nil {
		return nil, err
	}
	user := n.Customers[customerId].Users[username]
	err = user.Interface.PartialInterfaceShuffle()
	if err != nil {
		return nil, err
	}
	n.Customers[customerId].Users[username] = user
	return user.Interface.IdxInterface, nil
}

func (n *NKodeInMemory) Login(customerId m.CustomerId, username m.Username, keySelection m.KeySelection) error {
	customer, exists := n.Customers[customerId]
	if !exists {
		return errors.New(fmt.Sprintf("customer %s does not exist", customerId))
	}
	user, exists := customer.Users[username]
	if !exists {
		return errors.New(fmt.Sprintf("user dne %s", username))
	}
	passcode, err := customer.ValidKeyEntry(username, keySelection)
	if err != nil {
		return err
	}
	if user.Renew {
		err = user.RefreshPasscode(passcode, customer.Attributes)
		if err != nil {
			return err
		}
	}
	return nil
}

func (n *NKodeInMemory) customerUserExists(username m.Username, customerId m.CustomerId) error {
	customer, exists := n.Customers[customerId]
	if !exists {
		return errors.New(fmt.Sprintf("customer %s does not exist", customerId))
	}
	_, exists = customer.Users[username]
	if !exists {
		return errors.New(fmt.Sprintf("user dne %s", username))
	}
	return nil
}

func (n *NKodeInMemory) RenewAttributes(customerId m.CustomerId) error {
	customer, exists := n.Customers[customerId]
	if !exists {
		return errors.New(fmt.Sprintf("customer %s does not exist", customerId))
	}
	return customer.RenewKeys()
}