refactor errors

core/nkode_handler.go

@@ -26,6 +26,12 @@ const (
 	ResetNKode                   = "/reset-nkode"
 )
 
+const (
+	malformedCustomerId = "malformed customer id"
+	malformedUserEmail  = "malformed user email"
+	malformedSessionId  = "malformed session id"
+)
+
 func (h *NKodeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	switch r.URL.Path {
 	case CreateNewCustomer:
@@ -56,226 +62,148 @@ func (h *NKodeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 }
 
 func (h *NKodeHandler) CreateNewCustomerHandler(w http.ResponseWriter, r *http.Request) {
+	log.Print("create new customer")
 	if r.Method != http.MethodPost {
 		methodNotAllowed(w)
 		return
 	}
 	var customerPost NewCustomerPost
-	err := decodeJson(w, r, &customerPost)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+	if err := decodeJson(w, r, &customerPost); err != nil {
 		return
 	}
 	customerId, err := h.Api.CreateNewCustomer(customerPost.NKodePolicy, nil)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		handleError(w, err)
 		return
 	}
 	respBody := CreateNewCustomerResp{
 		CustomerId: uuid.UUID(*customerId).String(),
 	}
-	respBytes, err := json.Marshal(respBody)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
-		return
-	}
-	_, err = w.Write(respBytes)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
-		return
-	}
-
-	w.WriteHeader(http.StatusOK)
+	marshalAndWriteBytes(w, respBody)
 }
 
 func (h *NKodeHandler) GenerateSignupResetInterfaceHandler(w http.ResponseWriter, r *http.Request) {
+	log.Print("signup/reset interface")
 	if r.Method != http.MethodPost {
 		methodNotAllowed(w)
 		return
 	}
 
 	var signupResetPost GenerateSignupRestInterfacePost
-	err := decodeJson(w, r, &signupResetPost)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+	if err := decodeJson(w, r, &signupResetPost); err != nil {
 		return
 	}
+
 	kp := KeypadDimension{
 		AttrsPerKey: signupResetPost.AttrsPerKey,
 		NumbOfKeys:  signupResetPost.NumbOfKeys,
 	}
-	err = kp.IsValidKeypadDimension()
-	if err != nil {
-		keypadSizeOutOfRange(w)
-		log.Println(err)
+	if err := kp.IsValidKeypadDimension(); err != nil {
+		badRequest(w, "invalid keypad dimensions")
 		return
 	}
 	customerId, err := uuid.Parse(signupResetPost.CustomerId)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		badRequest(w, malformedCustomerId)
 		return
 	}
 	userEmail, err := ParseEmail(signupResetPost.UserEmail)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		badRequest(w, malformedUserEmail)
 		return
 	}
 	resp, err := h.Api.GenerateSignupResetInterface(userEmail, CustomerId(customerId), kp, signupResetPost.Reset)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
-		return
-	}
-	respBytes, err := json.Marshal(resp)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		handleError(w, err)
 		return
 	}
 
-	_, err = w.Write(respBytes)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
-		return
-	}
-
-	w.WriteHeader(http.StatusOK)
+	marshalAndWriteBytes(w, resp)
 }
 
 func (h *NKodeHandler) SetNKodeHandler(w http.ResponseWriter, r *http.Request) {
+	log.Print("set nkode")
 	if r.Method != http.MethodPost {
 		methodNotAllowed(w)
 		return
 	}
 	var setNKodePost SetNKodePost
-	err := decodeJson(w, r, &setNKodePost)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+	if err := decodeJson(w, r, &setNKodePost); err != nil {
 		return
 	}
 	customerId, err := uuid.Parse(setNKodePost.CustomerId)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		badRequest(w, malformedCustomerId)
 		return
 	}
 	sessionId, err := uuid.Parse(setNKodePost.SessionId)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		badRequest(w, malformedSessionId)
 		return
 	}
 	confirmInterface, err := h.Api.SetNKode(CustomerId(customerId), SessionId(sessionId), setNKodePost.KeySelection)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		handleError(w, err)
 		return
 	}
 	respBody := SetNKodeResp{UserInterface: confirmInterface}
-
-	respBytes, err := json.Marshal(respBody)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
-		return
-	}
-
-	_, err = w.Write(respBytes)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
-		return
-	}
-
-	w.WriteHeader(http.StatusOK)
+	marshalAndWriteBytes(w, respBody)
 }
 
 func (h *NKodeHandler) ConfirmNKodeHandler(w http.ResponseWriter, r *http.Request) {
+	log.Print("confirm nkode")
 	if r.Method != http.MethodPost {
 		methodNotAllowed(w)
 		return
 	}
 
 	var confirmNKodePost ConfirmNKodePost
-	err := decodeJson(w, r, &confirmNKodePost)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+	if err := decodeJson(w, r, &confirmNKodePost); err != nil {
 		return
 	}
 	customerId, err := uuid.Parse(confirmNKodePost.CustomerId)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		badRequest(w, malformedCustomerId)
 		return
 	}
 	sessionId, err := uuid.Parse(confirmNKodePost.SessionId)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		badRequest(w, malformedSessionId)
 		return
 	}
-	err = h.Api.ConfirmNKode(CustomerId(customerId), SessionId(sessionId), confirmNKodePost.KeySelection)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+	if err = h.Api.ConfirmNKode(CustomerId(customerId), SessionId(sessionId), confirmNKodePost.KeySelection); err != nil {
+		handleError(w, err)
 		return
 	}
-
 	w.WriteHeader(http.StatusOK)
-
 }
 
 func (h *NKodeHandler) GetLoginInterfaceHandler(w http.ResponseWriter, r *http.Request) {
+
 	if r.Method != http.MethodPost {
 		methodNotAllowed(w)
 		return
 	}
 	var loginInterfacePost GetLoginInterfacePost
-	err := decodeJson(w, r, &loginInterfacePost)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+	if err := decodeJson(w, r, &loginInterfacePost); err != nil {
 		return
 	}
 	customerId, err := uuid.Parse(loginInterfacePost.CustomerId)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		badRequest(w, malformedCustomerId)
 		return
 	}
 	userEmail, err := ParseEmail(loginInterfacePost.UserEmail)
+	if err != nil {
+		badRequest(w, malformedUserEmail)
+	}
 	loginInterface, err := h.Api.GetLoginInterface(userEmail, CustomerId(customerId))
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		handleError(w, err)
 		return
 	}
 
-	respBytes, err := json.Marshal(loginInterface)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
-		return
-	}
-	_, err = w.Write(respBytes)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
-		return
-	}
-
-	w.WriteHeader(http.StatusOK)
-
+	marshalAndWriteBytes(w, loginInterface)
 }
 
 func (h *NKodeHandler) LoginHandler(w http.ResponseWriter, r *http.Request) {
@@ -284,40 +212,26 @@ func (h *NKodeHandler) LoginHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	var loginPost LoginPost
-	err := decodeJson(w, r, &loginPost)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+	if err := decodeJson(w, r, &loginPost); err != nil {
 		return
 	}
 	customerId, err := uuid.Parse(loginPost.CustomerId)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		badRequest(w, malformedCustomerId)
 		return
 	}
 	userEmail, err := ParseEmail(loginPost.UserEmail)
+	if err != nil {
+		badRequest(w, malformedUserEmail)
+		return
+	}
 	jwtTokens, err := h.Api.Login(CustomerId(customerId), userEmail, loginPost.KeySelection)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		handleError(w, err)
 		return
 	}
 
-	respBytes, err := json.Marshal(jwtTokens)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
-		return
-	}
-	_, err = w.Write(respBytes)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
-		return
-	}
-
-	w.WriteHeader(http.StatusOK)
+	marshalAndWriteBytes(w, jwtTokens)
 }
 
 func (h *NKodeHandler) RenewAttributesHandler(w http.ResponseWriter, r *http.Request) {
@@ -326,23 +240,16 @@ func (h *NKodeHandler) RenewAttributesHandler(w http.ResponseWriter, r *http.Req
 		return
 	}
 	var renewAttributesPost RenewAttributesPost
-	err := decodeJson(w, r, &renewAttributesPost)
-
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+	if err := decodeJson(w, r, &renewAttributesPost); err != nil {
 		return
 	}
 	customerId, err := uuid.Parse(renewAttributesPost.CustomerId)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		badRequest(w, malformedCustomerId)
 		return
 	}
-	err = h.Api.RenewAttributes(CustomerId(customerId))
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+	if err = h.Api.RenewAttributes(CustomerId(customerId)); err != nil {
+		handleError(w, err)
 		return
 	}
 
@@ -355,26 +262,11 @@ func (h *NKodeHandler) RandomSvgInterfaceHandler(w http.ResponseWriter, r *http.
 	}
 	svgs, err := h.Api.RandomSvgInterface()
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		handleError(w, err)
 		return
 	}
 	respBody := RandomSvgInterfaceResp{Svgs: svgs}
-	respBytes, err := json.Marshal(respBody)
-
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
-		return
-	}
-	_, err = w.Write(respBytes)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
-		return
-	}
-
-	w.WriteHeader(http.StatusOK)
+	marshalAndWriteBytes(w, respBody)
 }
 
 func (h *NKodeHandler) RefreshTokenHandler(w http.ResponseWriter, r *http.Request) {
@@ -383,74 +275,54 @@ func (h *NKodeHandler) RefreshTokenHandler(w http.ResponseWriter, r *http.Reques
 	}
 	refreshToken, err := getBearerToken(r)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		forbidden(w)
 		return
 	}
-	refreshClaims, err := ParseRefreshToken(refreshToken)
+	refreshClaims, err := ParseRegisteredClaimToken(refreshToken)
 	customerId, err := uuid.Parse(refreshClaims.Issuer)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		badRequest(w, malformedCustomerId)
 		return
 	}
 	userEmail, err := ParseEmail(refreshClaims.Subject)
 	if err != nil {
-		internalServerErrorHandler(w)
+		badRequest(w, malformedUserEmail)
 		log.Println(err)
 		return
 	}
 	accessToken, err := h.Api.RefreshToken(userEmail, CustomerId(customerId), refreshToken)
 
 	if err != nil {
-		internalServerErrorHandler(w)
+		handleError(w, err)
 		log.Println(err)
 		return
 	}
-	respBytes, err := json.Marshal(RefreshTokenResp{AccessToken: accessToken})
-
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
-		return
-	}
-	_, err = w.Write(respBytes)
-
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
-		return
-	}
-	w.WriteHeader(http.StatusOK)
+	marshalAndWriteBytes(w, RefreshTokenResp{AccessToken: accessToken})
 }
 
 func (h *NKodeHandler) ResetNKode(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodPost {
 		methodNotAllowed(w)
 	}
-	log.Print("Resetting email")
 	var resetNKodePost ResetNKodePost
-	err := decodeJson(w, r, &resetNKodePost)
-	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println("error decoding reset nkode post: ", err)
+	if err := decodeJson(w, r, &resetNKodePost); err != nil {
 		return
 	}
+
 	customerId, err := uuid.Parse(resetNKodePost.CustomerId)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		badRequest(w, malformedCustomerId)
 		return
 	}
+
 	userEmail, err := ParseEmail(resetNKodePost.UserEmail)
 	if err != nil {
-		internalServerErrorHandler(w)
-		log.Println(err)
+		badRequest(w, malformedUserEmail)
 		return
 	}
-	err = h.Api.ResetNKode(userEmail, CustomerId(customerId))
-	if err != nil {
-		internalServerErrorHandler(w)
+
+	if err = h.Api.ResetNKode(userEmail, CustomerId(customerId)); err != nil {
+		internalServerError(w)
 		log.Println(err)
 		return
 	}
@@ -459,43 +331,90 @@ func (h *NKodeHandler) ResetNKode(w http.ResponseWriter, r *http.Request) {
 
 func decodeJson(w http.ResponseWriter, r *http.Request, post any) error {
 	if r.Body == nil {
-		invalidJson(w)
-		return errors.New("invalid json")
+		badRequest(w, "unable to parse body")
+		log.Println("error decoding json: body is nil")
+		return errors.New("body is nil")
 	}
 	err := json.NewDecoder(r.Body).Decode(&post)
 	if err != nil {
-		internalServerErrorHandler(w)
+		badRequest(w, "unable to parse body")
+		log.Println("error decoding json: ", err)
 		return err
 	}
 	return nil
 }
 
-func internalServerErrorHandler(w http.ResponseWriter) {
+func internalServerError(w http.ResponseWriter) {
+	log.Print("500 internal server error")
 	w.WriteHeader(http.StatusInternalServerError)
 	w.Write([]byte("500 Internal Server Error"))
 }
 
+func badRequest(w http.ResponseWriter, msg string) {
+	log.Print("bad request: ", msg)
+	w.WriteHeader(http.StatusBadRequest)
+	if msg == "" {
+		w.Write([]byte("400 Bad Request"))
+	} else {
+		w.Write([]byte(msg))
+	}
+}
+
 func methodNotAllowed(w http.ResponseWriter) {
+	log.Print("405 method not allowed")
 	w.WriteHeader(http.StatusMethodNotAllowed)
 	w.Write([]byte("405 method not allowed"))
 }
 
-func keypadSizeOutOfRange(w http.ResponseWriter) {
-	w.WriteHeader(http.StatusBadRequest)
-	w.Write([]byte("invalid keypad dimensions"))
+func forbidden(w http.ResponseWriter) {
+	log.Print("403 forbidden")
+	w.WriteHeader(http.StatusForbidden)
+	w.Write([]byte("403 Forbidden"))
 }
 
-func invalidJson(w http.ResponseWriter) {
-	w.WriteHeader(http.StatusBadRequest)
-	w.Write([]byte("invalid json"))
+func handleError(w http.ResponseWriter, err error) {
+	log.Print("handling error: ", err)
+	statusCode, exists := HttpErrMap[err]
+	if !exists {
+		internalServerError(w)
+		return
+	}
+	switch statusCode {
+	case http.StatusBadRequest:
+		badRequest(w, err.Error())
+	case http.StatusForbidden:
+		forbidden(w)
+	case http.StatusInternalServerError:
+		internalServerError(w)
+	default:
+		log.Print("unknown error: ", err)
+		internalServerError(w)
+	}
 }
 
 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")
+		return "", errors.New("forbidden")
 	}
 	token := strings.TrimPrefix(authHeader, "Bearer ")
 	return token, nil
 }
+
+func marshalAndWriteBytes(w http.ResponseWriter, data any) {
+	respBytes, err := json.Marshal(data)
+
+	if err != nil {
+		internalServerError(w)
+		log.Println(err)
+		return
+	}
+	_, err = w.Write(respBytes)
+
+	if err != nil {
+		internalServerError(w)
+		log.Println(err)
+		return
+	}
+}