go-nkode/core/api/nkode_handler.go

package api

import (
	"encoding/json"
	"go-nkode/core/model"
	"go-nkode/core/nkode"
	"log"
	"net/http"
)

type NKodeHandler struct {
	Api nkode.NKodeAPI
}

func (h *NKodeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	switch r.URL.Path {
	case CreateNewCustomer:
		h.CreateNewCustomerHandler(w, r)
		return
	case GenerateSignupInterface:
		h.GenerateSignupInterfaceHandler(w, r)
	case SetNKode:
		h.SetNKodeHandler(w, r)
	case ConfirmNKode:
		h.ConfirmNKodeHandler(w, r)
	case GetLoginInterface:
		h.GetLoginInterfaceHandler(w, r)
	case Login:
		h.LoginHandler(w, r)
	case RenewAttributes:
		h.RenewAttributesHandler(w, r)
	default:
		w.WriteHeader(http.StatusNotFound)
		w.Write([]byte("404 not found"))
		log.Fatal(r.URL.Path, " not found")
	}
}

func (h *NKodeHandler) CreateNewCustomerHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		methodNotAllowed(w)
		return
	}
	var customerPost model.NewCustomerPost
	err := decodeJson(w, r, &customerPost)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}
	customerId, err := h.Api.CreateNewCustomer(customerPost.KeypadSize, customerPost.NKodePolicy)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}
	respBody := model.CreateNewCustomerResp{
		CustomerId: *customerId,
	}
	respBytes, err := json.Marshal(respBody)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}
	_, err = w.Write(respBytes)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}

	w.WriteHeader(http.StatusOK)
}

func (h *NKodeHandler) GenerateSignupInterfaceHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		methodNotAllowed(w)
		return
	}

	var signupPost model.GenerateSignupInterfacePost
	err := decodeJson(w, r, &signupPost)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}
	sessionId, userInterface, err := h.Api.GenerateSignupInterface(signupPost.CustomerId)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}
	respBody := model.GenerateSignupInterfaceResp{
		SessionId:     *sessionId,
		UserInterface: userInterface,
	}
	respBytes, err := json.Marshal(respBody)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}

	_, err = w.Write(respBytes)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}

	w.WriteHeader(http.StatusOK)
}

func (h *NKodeHandler) SetNKodeHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		methodNotAllowed(w)
		return
	}
	var setNKodePost model.SetNKodePost
	err := decodeJson(w, r, &setNKodePost)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}
	confirmInterface, err := h.Api.SetNKode(setNKodePost.Username, setNKodePost.CustomerId, setNKodePost.KeySelection, setNKodePost.SessionId)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}
	respBody := model.SetNKodeResp{UserInterface: confirmInterface}

	respBytes, err := json.Marshal(respBody)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}

	_, err = w.Write(respBytes)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}

	w.WriteHeader(http.StatusOK)
}

func (h *NKodeHandler) ConfirmNKodeHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		methodNotAllowed(w)
		return
	}

	var confirmNKodePost model.ConfirmNKodePost
	err := decodeJson(w, r, &confirmNKodePost)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}
	err = h.Api.ConfirmNKode(confirmNKodePost.CustomerId, confirmNKodePost.KeySelection, confirmNKodePost.SessionId)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(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 model.GetLoginInterfacePost
	err := decodeJson(w, r, &loginInterfacePost)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}
	loginInterface, err := h.Api.GetLoginInterface(loginInterfacePost.Username, loginInterfacePost.CustomerId)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}

	respBody := model.GetLoginInterfaceResp{UserInterface: loginInterface}
	respBytes, err := json.Marshal(respBody)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}
	_, err = w.Write(respBytes)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}

	w.WriteHeader(http.StatusOK)

}

func (h *NKodeHandler) LoginHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		methodNotAllowed(w)
		return
	}
	var loginPost model.LoginPost
	err := decodeJson(w, r, &loginPost)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}
	err = h.Api.Login(loginPost.CustomerId, loginPost.Username, loginPost.KeySelection)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}

	w.WriteHeader(http.StatusOK)
}

func (h *NKodeHandler) RenewAttributesHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		methodNotAllowed(w)
		return
	}
	var renewAttributesPost model.RenewAttributesPost
	err := decodeJson(w, r, &renewAttributesPost)

	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}

	err = h.Api.RenewAttributes(renewAttributesPost.CustomerId)
	if err != nil {
		internalServerErrorHandler(w, r)
		log.Fatal(err)
		return
	}

	w.WriteHeader(http.StatusOK)
}

func decodeJson(w http.ResponseWriter, r *http.Request, post any) error {
	err := json.NewDecoder(r.Body).Decode(&post)
	if err != nil {
		internalServerErrorHandler(w, r)
		return err
	}
	return nil

}

func internalServerErrorHandler(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusInternalServerError)
	w.Write([]byte("500 Internal Server Error"))
}

func methodNotAllowed(w http.ResponseWriter) {
	w.WriteHeader(http.StatusMethodNotAllowed)
	w.Write([]byte("405 method not allowed"))
}