1 files changed, 38 insertions, 51 deletions

diff --git a/server/admin/handler.go b/server/admin/handler.go
index 29e2c11..b8f1d7f 100644
--- a/server/admin/handler.go
+++ b/server/admin/handler.go
@@ -6,6 +6,7 @@ import (
 	"os"
 	"time"
 
+	"git.huntm.net/wedding/server/errors"
 	"git.huntm.net/wedding/server/guest"
 	"github.com/golang-jwt/jwt/v5"
 )
@@ -19,86 +20,72 @@ type adminStore interface {
 	Find(admin Admin) (Admin, error)
 }
 
-type appError struct {
-	Error   error
-	Message string
-	Code    int
+func NewAdminHandler(a adminStore, g guest.GuestStore) *AdminHandler {
+	return &AdminHandler{a, g}
 }
 
-func NewAdminHandler(adminStore adminStore, guestStore guest.GuestStore) *AdminHandler {
-	return &AdminHandler{adminStore, guestStore}
-}
-
-func (adminHandler *AdminHandler) ServeHTTP(responseWriter http.ResponseWriter,
-	request *http.Request) {
+func (a *AdminHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	switch {
-	case request.Method == http.MethodOptions:
-		responseWriter.WriteHeader(http.StatusOK)
-	case request.Method == http.MethodPost && request.URL.Path == "/api/admin/login":
-		adminHandler.handleLogIn(responseWriter, request)
+	case r.Method == http.MethodOptions:
+		w.WriteHeader(http.StatusOK)
+	case r.Method == http.MethodPost && r.URL.Path == "/api/admin/login":
+		a.handleLogIn(w, r)
 	default:
-		responseWriter.WriteHeader(http.StatusNotFound)
+		w.WriteHeader(http.StatusNotFound)
 	}
 }
 
-func (adminHandler *AdminHandler) handleLogIn(responseWriter http.ResponseWriter,
-	request *http.Request) {
-	token, err := adminHandler.logIn(request)
+func (a *AdminHandler) handleLogIn(w http.ResponseWriter, r *http.Request) {
+	token, err := a.logIn(r)
 	if err != nil {
-		http.Error(responseWriter, err.Message, err.Code)
+		http.Error(w, string(err.Message), err.Status)
 	} else {
-		responseWriter.Write(token)
+		w.Write(token)
 	}
 }
 
-func (adminHandler *AdminHandler) logIn(request *http.Request) ([]byte, *appError) {
-	requestAdmin, err := adminHandler.decodeCredentials(request)
+func (a *AdminHandler) logIn(r *http.Request) ([]byte, *errors.AppError) {
+	requestAdmin, err := a.decodeCredentials(r)
 	if err != nil {
-		return []byte{}, &appError{err, "{ \"message\": \"Failed to unmarshal request\" }",
-			http.StatusBadRequest}
+		return nil, errors.NewAppError(http.StatusBadRequest, err.Error())
 	}
-	_, err = adminHandler.adminStore.Find(requestAdmin)
+	_, err = a.adminStore.Find(requestAdmin)
 	if err != nil {
-		return []byte{}, &appError{err, "{ \"message\": \"Invalid username or password\" }",
-			http.StatusUnauthorized}
+		return nil, errors.NewAppError(http.StatusUnauthorized, err.Error())
 	}
-	expirationTime := adminHandler.setExpirationTime()
-	claims := adminHandler.createClaims(requestAdmin, expirationTime)
-	key, err := adminHandler.readKey()
+	expirationTime := a.setExpirationTime()
+	claims := a.createClaims(requestAdmin, expirationTime)
+	key, err := a.readKey()
 	if err != nil {
-		return []byte{}, &appError{err, "{ \"message\": \"Failed to read secret key\" }",
-			http.StatusInternalServerError}
+		return nil, errors.NewAppError(http.StatusInternalServerError, err.Error())
 	}
-	token, err := adminHandler.createToken(claims, key)
+	token, err := a.createToken(claims, key)
 	if err != nil {
-		return []byte{}, &appError{err, "{ \"message\": \"Failed to create token\" }",
-			http.StatusInternalServerError}
+		return nil, errors.NewAppError(http.StatusInternalServerError, err.Error())
 	}
-	guests, err := adminHandler.guestStore.Get()
+	guests, err := a.guestStore.Get()
 	if err != nil {
-		return []byte{}, &appError{err, "{ \"message\": \"Failed to get guests\" }",
-			http.StatusInternalServerError}
+		return nil, errors.NewAppError(http.StatusInternalServerError, err.Error())
 	}
-	jsonBytes, err := adminHandler.marshalResponse(guests, token)
+	jsonBytes, err := a.marshalResponse(guests, token)
 	if err != nil {
-		return []byte{}, &appError{err, "{ \"message\": \"Failed to marshal response\" }",
-			http.StatusInternalServerError}
+		return nil, errors.NewAppError(http.StatusInternalServerError, err.Error())
 	}
 	return jsonBytes, nil
 }
 
-func (adminHandler *AdminHandler) decodeCredentials(request *http.Request) (Admin, error) {
+func (a *AdminHandler) decodeCredentials(r *http.Request) (Admin, error) {
 	var admin Admin
-	err := json.NewDecoder(request.Body).Decode(&admin)
-	defer request.Body.Close()
+	err := json.NewDecoder(r.Body).Decode(&admin)
+	defer r.Body.Close()
 	return admin, err
 }
 
-func (adminHandler *AdminHandler) setExpirationTime() time.Time {
+func (a *AdminHandler) setExpirationTime() time.Time {
 	return time.Now().Add(15 * time.Minute)
 }
 
-func (adminHandler *AdminHandler) createClaims(admin Admin, expirationTime time.Time) *Claims {
+func (a *AdminHandler) createClaims(admin Admin, expirationTime time.Time) *Claims {
 	return &Claims{
 		admin,
 		jwt.RegisteredClaims{
@@ -107,22 +94,22 @@ func (adminHandler *AdminHandler) createClaims(admin Admin, expirationTime time.
 	}
 }
 
-func (adminHandler *AdminHandler) readKey() ([]byte, error) {
+func (a *AdminHandler) readKey() ([]byte, error) {
 	return os.ReadFile(os.Getenv("ADMIN_KEY"))
 }
 
-func (adminHandler *AdminHandler) createToken(claims *Claims, key []byte) (string, error) {
+func (a *AdminHandler) createToken(claims *Claims, key []byte) (string, error) {
 	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
 	return token.SignedString(key)
 }
 
-func (adminHandler *AdminHandler) marshalResponse(guests []guest.Guest,
+func (a *AdminHandler) marshalResponse(guests []guest.Guest,
 	token string) ([]byte, error) {
-	loginResponse := adminHandler.createLoginResponse(guests, token)
+	loginResponse := a.createLoginResponse(guests, token)
 	return json.Marshal(loginResponse)
 }
 
-func (adminHandler *AdminHandler) createLoginResponse(guests []guest.Guest,
+func (a *AdminHandler) createLoginResponse(guests []guest.Guest,
 	token string) *Login {
 	return &Login{guests, token}
 }