implement reset nkode

core/nkode_handler.go

@@ -6,6 +6,7 @@ import (
 	"github.com/google/uuid"
 	"log"
 	"net/http"
+	"strings"
 )
 
 type NKodeHandler struct {
@@ -13,23 +14,24 @@ type NKodeHandler struct {
 }
 
 const (
-	CreateNewCustomer       = "/create-new-customer"
-	GenerateSignupInterface = "/generate-signup-interface"
-	SetNKode                = "/set-nkode"
-	ConfirmNKode            = "/confirm-nkode"
-	GetLoginInterface       = "/get-login-interface"
-	Login                   = "/login"
-	RenewAttributes         = "/renew-attributes"
-	RandomSvgInterface      = "/random-svg-interface"
-	RefreshToken            = "/refresh-token"
+	CreateNewCustomer            = "/create-new-customer"
+	GenerateSignupResetInterface = "/generate-signup-reset-interface"
+	SetNKode                     = "/set-nkode"
+	ConfirmNKode                 = "/confirm-nkode"
+	GetLoginInterface            = "/get-login-interface"
+	Login                        = "/login"
+	RenewAttributes              = "/renew-attributes"
+	RandomSvgInterface           = "/random-svg-interface"
+	RefreshToken                 = "/refresh-token"
+	ResetNKode                   = "/reset-nkode"
 )
 
 func (h *NKodeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	switch r.URL.Path {
 	case CreateNewCustomer:
 		h.CreateNewCustomerHandler(w, r)
-	case GenerateSignupInterface:
-		h.GenerateSignupInterfaceHandler(w, r)
+	case GenerateSignupResetInterface:
+		h.GenerateSignupResetInterfaceHandler(w, r)
 	case SetNKode:
 		h.SetNKodeHandler(w, r)
 	case ConfirmNKode:
@@ -44,6 +46,8 @@ func (h *NKodeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		h.RandomSvgInterfaceHandler(w, r)
 	case RefreshToken:
 		h.RefreshTokenHandler(w, r)
+	case ResetNKode:
+		h.ResetNKode(w, r)
 	default:
 		w.WriteHeader(http.StatusNotFound)
 		_, err := w.Write([]byte("404 not found"))
@@ -88,23 +92,22 @@ func (h *NKodeHandler) CreateNewCustomerHandler(w http.ResponseWriter, r *http.R
 	w.WriteHeader(http.StatusOK)
 }
 
-func (h *NKodeHandler) GenerateSignupInterfaceHandler(w http.ResponseWriter, r *http.Request) {
+func (h *NKodeHandler) GenerateSignupResetInterfaceHandler(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodPost {
 		methodNotAllowed(w)
 		return
 	}
-	log.Print("signup interface")
 
-	var signupPost GenerateSignupInterfacePost
-	err := decodeJson(w, r, &signupPost)
+	var signupResetPost GenerateSignupRestInterfacePost
+	err := decodeJson(w, r, &signupResetPost)
 	if err != nil {
 		internalServerErrorHandler(w)
 		log.Println(err)
 		return
 	}
 	kp := KeypadDimension{
-		AttrsPerKey: signupPost.AttrsPerKey,
-		NumbOfKeys:  signupPost.NumbOfKeys,
+		AttrsPerKey: signupResetPost.AttrsPerKey,
+		NumbOfKeys:  signupResetPost.NumbOfKeys,
 	}
 	err = kp.IsValidKeypadDimension()
 	if err != nil {
@@ -112,14 +115,19 @@ func (h *NKodeHandler) GenerateSignupInterfaceHandler(w http.ResponseWriter, r *
 		log.Println(err)
 		return
 	}
-	customerId, err := uuid.Parse(signupPost.CustomerId)
+	customerId, err := uuid.Parse(signupResetPost.CustomerId)
 	if err != nil {
 		internalServerErrorHandler(w)
 		log.Println(err)
 		return
 	}
-	userEmail, err := ParseEmail(signupPost.UserEmail)
-	resp, err := h.Api.GenerateSignupInterface(userEmail, CustomerId(customerId), kp)
+	userEmail, err := ParseEmail(signupResetPost.UserEmail)
+	if err != nil {
+		internalServerErrorHandler(w)
+		log.Println(err)
+		return
+	}
+	resp, err := h.Api.GenerateSignupResetInterface(userEmail, CustomerId(customerId), kp, signupResetPost.Reset)
 	if err != nil {
 		internalServerErrorHandler(w)
 		log.Println(err)
@@ -370,30 +378,29 @@ func (h *NKodeHandler) RandomSvgInterfaceHandler(w http.ResponseWriter, r *http.
 }
 
 func (h *NKodeHandler) RefreshTokenHandler(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodPost {
+	if r.Method != http.MethodGet {
 		methodNotAllowed(w)
 	}
-	var refreshTokenPost RefreshTokenPost
-	err := decodeJson(w, r, &refreshTokenPost)
-
+	refreshToken, err := getBearerToken(r)
 	if err != nil {
 		internalServerErrorHandler(w)
 		log.Println(err)
 		return
 	}
-	customerId, err := uuid.Parse(refreshTokenPost.CustomerId)
+	refreshClaims, err := ParseRefreshToken(refreshToken)
+	customerId, err := uuid.Parse(refreshClaims.Issuer)
 	if err != nil {
 		internalServerErrorHandler(w)
 		log.Println(err)
 		return
 	}
-	userEmail, err := ParseEmail(refreshTokenPost.UserEmail)
+	userEmail, err := ParseEmail(refreshClaims.Subject)
 	if err != nil {
 		internalServerErrorHandler(w)
 		log.Println(err)
 		return
 	}
-	accessToken, err := h.Api.RefreshToken(userEmail, CustomerId(customerId), refreshTokenPost.RefreshToken)
+	accessToken, err := h.Api.RefreshToken(userEmail, CustomerId(customerId), refreshToken)
 
 	if err != nil {
 		internalServerErrorHandler(w)
@@ -417,6 +424,38 @@ func (h *NKodeHandler) RefreshTokenHandler(w http.ResponseWriter, r *http.Reques
 	w.WriteHeader(http.StatusOK)
 }
 
+func (h *NKodeHandler) ResetNKode(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		methodNotAllowed(w)
+	}
+	var resetNKodePost ResetNKodePost
+	err := decodeJson(w, r, &resetNKodePost)
+	if err != nil {
+		internalServerErrorHandler(w)
+		log.Println("error decoding reset nkode post: ", err)
+		return
+	}
+	customerId, err := uuid.Parse(resetNKodePost.CustomerId)
+	if err != nil {
+		internalServerErrorHandler(w)
+		log.Println(err)
+		return
+	}
+	userEmail, err := ParseEmail(resetNKodePost.UserEmail)
+	if err != nil {
+		internalServerErrorHandler(w)
+		log.Println(err)
+		return
+	}
+	err = h.Api.ResetNKode(userEmail, CustomerId(customerId))
+	if err != nil {
+		internalServerErrorHandler(w)
+		log.Println(err)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+}
+
 func decodeJson(w http.ResponseWriter, r *http.Request, post any) error {
 	if r.Body == nil {
 		invalidJson(w)
@@ -449,3 +488,13 @@ func invalidJson(w http.ResponseWriter) {
 	w.WriteHeader(http.StatusBadRequest)
 	w.Write([]byte("invalid json"))
 }
+
+func getBearerToken(r *http.Request) (string, error) {
+	authHeader := r.Header.Get("Authorization")
+	// Check if the Authorization header is present and starts with "Bearer "
+	if authHeader == "" || !strings.HasPrefix(authHeader, "Bearer ") {
+		return "", errors.New("authorization header missing or invalid")
+	}
+	token := strings.TrimPrefix(authHeader, "Bearer ")
+	return token, nil
+}