Add ui error messages

3 files changed, 84 insertions, 44 deletions

diff --git a/server/admin/handler.go b/server/admin/handler.go
index f2d5807..b05fc88 100644
--- a/server/admin/handler.go
+++ b/server/admin/handler.go
@@ -29,7 +29,8 @@ func NewAdminHandler(adminStore adminStore, guestStore guest.GuestStore) *AdminH
 	return &AdminHandler{adminStore, guestStore}
 }
 
-func (adminHandler *AdminHandler) ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) {
+func (adminHandler *AdminHandler) ServeHTTP(responseWriter http.ResponseWriter,
+	request *http.Request) {
 	switch {
 	case request.Method == http.MethodOptions:
 		responseWriter.WriteHeader(http.StatusOK)
@@ -40,7 +41,8 @@ func (adminHandler *AdminHandler) ServeHTTP(responseWriter http.ResponseWriter,
 	}
 }
 
-func (adminHandler *AdminHandler) handleLogIn(responseWriter http.ResponseWriter, request *http.Request) {
+func (adminHandler *AdminHandler) handleLogIn(responseWriter http.ResponseWriter,
+	request *http.Request) {
 	token, err := adminHandler.logIn(request)
 	if err != nil {
 		http.Error(responseWriter, err.Message, err.Code)
@@ -52,29 +54,35 @@ func (adminHandler *AdminHandler) handleLogIn(responseWriter http.ResponseWriter
 func (adminHandler *AdminHandler) logIn(request *http.Request) ([]byte, *appError) {
 	requestAdmin, err := adminHandler.decodeCredentials(request)
 	if err != nil {
-		return []byte{}, &appError{err, "failed to unmarshal request", http.StatusBadRequest}
+		return []byte{}, &appError{err, "{ \"message\": \"Failed to unmarshal request\" }",
+			http.StatusBadRequest}
 	}
 	_, err = adminHandler.adminStore.Find(requestAdmin)
 	if err != nil {
-		return []byte{}, &appError{err, "admin not found", http.StatusUnauthorized}
+		return []byte{}, &appError{err, "{ \"message\": \"Admin not found\" }",
+			http.StatusUnauthorized}
 	}
 	expirationTime := adminHandler.setExpirationTime()
 	claims := adminHandler.createClaims(requestAdmin, expirationTime)
 	key, err := adminHandler.readKey()
 	if err != nil {
-		return []byte{}, &appError{err, "failed to read secret key", http.StatusInternalServerError}
+		return []byte{}, &appError{err, "{ \"message\": \"Failed to read secret key\" }",
+			http.StatusInternalServerError}
 	}
 	token, err := adminHandler.createToken(claims, key)
 	if err != nil {
-		return []byte{}, &appError{err, "failed to create token", http.StatusInternalServerError}
+		return []byte{}, &appError{err, "{ \"message\": \"Failed to create token\" }",
+			http.StatusInternalServerError}
 	}
 	guests, err := adminHandler.guestStore.Get()
 	if err != nil {
-		return []byte{}, &appError{err, "failed to get guests", http.StatusInternalServerError}
+		return []byte{}, &appError{err, "{ \"message\": \"Failed to get guests\" }",
+			http.StatusInternalServerError}
 	}
 	jsonBytes, err := adminHandler.marshalResponse(guests, token)
 	if err != nil {
-		return []byte{}, &appError{err, "failed to marshal response", http.StatusInternalServerError}
+		return []byte{}, &appError{err, "{ \"message\": \"Failed to marshal response\" }",
+			http.StatusInternalServerError}
 	}
 	return jsonBytes, nil
 }
@@ -109,11 +117,13 @@ func (adminHandler *AdminHandler) createToken(claims *Claims, key []byte) (strin
 	return token.SignedString(key)
 }
 
-func (adminHandler *AdminHandler) marshalResponse(guests []guest.Guest, token string) ([]byte, error) {
+func (adminHandler *AdminHandler) marshalResponse(guests []guest.Guest,
+	token string) ([]byte, error) {
 	loginResponse := adminHandler.createLoginResponse(guests, token)
 	return json.Marshal(loginResponse)
 }
 
-func (adminHandler *AdminHandler) createLoginResponse(guests []guest.Guest, token string) *Login {
+func (adminHandler *AdminHandler) createLoginResponse(guests []guest.Guest,
+	token string) *Login {
 	return &Login{guests, token}
 }
diff --git a/server/guest/handler.go b/server/guest/handler.go
index e4ba3f3..04adc0c 100644
--- a/server/guest/handler.go
+++ b/server/guest/handler.go
@@ -41,7 +41,8 @@ func NewGuestHandler(guestStore GuestStore) *GuestHandler {
 	}
 }
 
-func (handler *GuestHandler) ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) {
+func (handler *GuestHandler) ServeHTTP(responseWriter http.ResponseWriter,
+	request *http.Request) {
 	switch {
 	case request.Method == http.MethodOptions:
 		responseWriter.WriteHeader(http.StatusOK)
@@ -60,7 +61,8 @@ func (handler *GuestHandler) ServeHTTP(responseWriter http.ResponseWriter, reque
 	}
 }
 
-func (handler *GuestHandler) handleLogIn(responseWriter http.ResponseWriter, request *http.Request) {
+func (handler *GuestHandler) handleLogIn(responseWriter http.ResponseWriter,
+	request *http.Request) {
 	token, err := handler.logIn(request)
 	if err != nil {
 		http.Error(responseWriter, err.Message, err.Code)
@@ -69,7 +71,8 @@ func (handler *GuestHandler) handleLogIn(responseWriter http.ResponseWriter, req
 	}
 }
 
-func (handler *GuestHandler) handlePut(responseWriter http.ResponseWriter, request *http.Request) {
+func (handler *GuestHandler) handlePut(responseWriter http.ResponseWriter,
+	request *http.Request) {
 	if err := handler.putGuest(request); err != nil {
 		http.Error(responseWriter, err.Message, err.Code)
 	} else {
@@ -77,7 +80,8 @@ func (handler *GuestHandler) handlePut(responseWriter http.ResponseWriter, reque
 	}
 }
 
-func (handler *GuestHandler) handleGet(responseWriter http.ResponseWriter, request *http.Request) {
+func (handler *GuestHandler) handleGet(responseWriter http.ResponseWriter,
+	request *http.Request) {
 	guests, err := handler.getGuests(request)
 	if err != nil {
 		http.Error(responseWriter, err.Message, err.Code)
@@ -86,7 +90,8 @@ func (handler *GuestHandler) handleGet(responseWriter http.ResponseWriter, reque
 	}
 }
 
-func (handler *GuestHandler) handlePost(responseWriter http.ResponseWriter, request *http.Request) {
+func (handler *GuestHandler) handlePost(responseWriter http.ResponseWriter,
+	request *http.Request) {
 	if err := handler.postGuest(request); err != nil {
 		http.Error(responseWriter, err.Message, err.Code)
 	} else {
@@ -94,7 +99,8 @@ func (handler *GuestHandler) handlePost(responseWriter http.ResponseWriter, requ
 	}
 }
 
-func (handler *GuestHandler) handleDelete(responseWriter http.ResponseWriter, request *http.Request) {
+func (handler *GuestHandler) handleDelete(responseWriter http.ResponseWriter,
+	request *http.Request) {
 	if err := handler.deleteGuest(request); err != nil {
 		http.Error(responseWriter, err.Message, err.Code)
 	} else {
@@ -105,25 +111,30 @@ func (handler *GuestHandler) handleDelete(responseWriter http.ResponseWriter, re
 func (handler *GuestHandler) logIn(request *http.Request) ([]byte, *appError) {
 	name, err := handler.decodeName(request)
 	if err != nil {
-		return []byte{}, &appError{err, "failed to unmarshal name", http.StatusBadRequest}
+		return []byte{}, &appError{err, "{ \" message\": \"Failed to unmarshal name\" }",
+			http.StatusBadRequest}
 	}
 	guest, err := handler.store.Find(name)
 	if err != nil {
-		return []byte{}, &appError{err, "guest not found", http.StatusUnauthorized}
+		return []byte{}, &appError{err, "{ \"message\": \"Guest not found\" }",
+			http.StatusUnauthorized}
 	}
 	expirationTime := handler.setExpirationTime()
 	claims := handler.createClaims(name, expirationTime)
 	key, err := handler.readGuestKey()
 	if err != nil {
-		return []byte{}, &appError{err, "failed to read secret key", http.StatusInternalServerError}
+		return []byte{}, &appError{err, "{ \"message\": \"Failed to read secret key\" }",
+			http.StatusInternalServerError}
 	}
 	token, err := handler.createToken(claims, key)
 	if err != nil {
-		return []byte{}, &appError{err, "failed to create token", http.StatusInternalServerError}
+		return []byte{}, &appError{err, "{ \"message\": \"Failed to create token\" }",
+			http.StatusInternalServerError}
 	}
 	jsonBytes, err := handler.marshalResponse(guest, token)
 	if err != nil {
-		return []byte{}, &appError{err, "failed to marshal response", http.StatusInternalServerError}
+		return []byte{}, &appError{err, "{ \"message\": \"Failed to marshal response\" }",
+			http.StatusInternalServerError}
 	}
 	return jsonBytes, nil
 }
@@ -177,20 +188,24 @@ func (handler *GuestHandler) createLoginResponse(weddingGuest Guest, token strin
 func (handler *GuestHandler) putGuest(request *http.Request) *appError {
 	guestKey, err := handler.readGuestKey()
 	if err != nil {
-		return &appError{err, "failed to read secret key", http.StatusInternalServerError}
+		return &appError{err, "{ \"message\": \"Failed to read secret key\" }",
+			http.StatusInternalServerError}
 	}
 	if err := handler.validateToken(request, guestKey); err != nil {
 		return err
 	}
 	if handler.findID(request) {
-		return &appError{errors.New("id not found"), "id not found", http.StatusNotFound}
+		return &appError{errors.New("ID not found"), "{ \"message\": \"ID not found\" }",
+			http.StatusNotFound}
 	}
 	guest, err := handler.decodeGuest(request)
 	if err != nil {
-		return &appError{err, "invalid guest", http.StatusBadRequest}
+		return &appError{err, "{ \"message\": \"Invalid guest\" }",
+			http.StatusBadRequest}
 	}
 	if err := handler.store.Update(guest); err != nil {
-		return &appError{err, "failed to update guest", http.StatusInternalServerError}
+		return &appError{err, "{ \"message\": \"Failed to update guest\" }",
+			http.StatusInternalServerError}
 	}
 	return nil
 }
@@ -201,12 +216,15 @@ func (handler *GuestHandler) validateToken(request *http.Request, key []byte) *a
 	token, err := handler.parseWithClaims(authorizationHeader, claims, key)
 	if err != nil {
 		if err == jwt.ErrSignatureInvalid {
-			return &appError{err, "invalid signature", http.StatusUnauthorized}
+			return &appError{err, "{ \"message\": \"Invalid signature\" }",
+				http.StatusUnauthorized}
 		}
-		return &appError{err, "failed to parse claims", http.StatusBadRequest}
+		return &appError{err, "{ \"message\": \"Failed to parse claims\" }",
+			http.StatusBadRequest}
 	}
 	if !token.Valid {
-		return &appError{err, "invalid token", http.StatusUnauthorized}
+		return &appError{err, "{ \"message\": \"Invalid token\" }",
+			http.StatusUnauthorized}
 	}
 	return nil
 }
@@ -219,7 +237,8 @@ func (handler *GuestHandler) newClaims() *Claims {
 	return &Claims{}
 }
 
-func (handler *GuestHandler) parseWithClaims(token string, claims *Claims, key []byte) (*jwt.Token, error) {
+func (handler *GuestHandler) parseWithClaims(token string, claims *Claims,
+	key []byte) (*jwt.Token, error) {
 	return jwt.ParseWithClaims(token, claims, func(token *jwt.Token) (any, error) {
 		return key, nil
 	})
@@ -240,18 +259,21 @@ func (handler *GuestHandler) decodeGuest(request *http.Request) (Guest, error) {
 func (handler *GuestHandler) getGuests(request *http.Request) ([]byte, *appError) {
 	adminKey, err := handler.readAdminKey()
 	if err != nil {
-		return []byte{}, &appError{err, "failed to read secret key", http.StatusInternalServerError}
+		return []byte{}, &appError{err, "{ \"message\": \"Failed to read secret key\" }",
+			http.StatusInternalServerError}
 	}
 	if err := handler.validateToken(request, adminKey); err != nil {
 		return []byte{}, err
 	}
 	guests, err := handler.store.Get()
 	if err != nil {
-		return []byte{}, &appError{err, "failed to get guests", http.StatusInternalServerError}
+		return []byte{}, &appError{err, "{ \"message\": \"Failed to get guests\" }",
+			http.StatusInternalServerError}
 	}
 	jsonBytes, err := json.Marshal(guests)
 	if err != nil {
-		return []byte{}, &appError{err, "failed to marshal guests", http.StatusInternalServerError}
+		return []byte{}, &appError{err, "{ \"message\": \"Failed to marshal guests\" }",
+			http.StatusInternalServerError}
 	}
 	return jsonBytes, nil
 }
@@ -259,24 +281,29 @@ func (handler *GuestHandler) getGuests(request *http.Request) ([]byte, *appError
 func (handler *GuestHandler) postGuest(request *http.Request) *appError {
 	adminKey, err := handler.readAdminKey()
 	if err != nil {
-		return &appError{err, "failed to read secret key", http.StatusInternalServerError}
+		return &appError{err, "{ \"message\": \"Failed to read secret key\" }",
+			http.StatusInternalServerError}
 	}
 	if err := handler.validateToken(request, adminKey); err != nil {
 		return err
 	}
 	guest, err := handler.decodeGuest(request)
 	if err != nil {
-		return &appError{err, "invalid guest", http.StatusBadRequest}
+		return &appError{err, "{ \"message\": \"Invalid guest\" }",
+			http.StatusBadRequest}
 	}
 	guests, err := handler.store.Get()
 	if err != nil {
-		return &appError{err, "failed to get guests", http.StatusInternalServerError}
+		return &appError{err, "{ \"message\": \"Failed to get guests\" }",
+			http.StatusInternalServerError}
 	}
 	if err := handler.checkExistingGuests(guests, guest); err != nil {
-		return &appError{err, "id already exists", http.StatusConflict}
+		return &appError{err, "{ \"message\": \"ID already exists\" }",
+			http.StatusConflict}
 	}
 	if err := handler.store.Add(guest); err != nil {
-		return &appError{err, "failed to add guest", http.StatusInternalServerError}
+		return &appError{err, "{ \"message\": \"Failed to add guest\" }",
+			http.StatusInternalServerError}
 	}
 	return nil
 }
@@ -284,7 +311,7 @@ func (handler *GuestHandler) postGuest(request *http.Request) *appError {
 func (handler *GuestHandler) checkExistingGuests(guests []Guest, newGuest Guest) error {
 	for _, guest := range guests {
 		if guest.ID == newGuest.ID {
-			return errors.New("id already exists")
+			return errors.New("ID already exists")
 		}
 	}
 	return nil
@@ -293,21 +320,24 @@ func (handler *GuestHandler) checkExistingGuests(guests []Guest, newGuest Guest)
 func (handler *GuestHandler) deleteGuest(request *http.Request) *appError {
 	adminKey, err := handler.readAdminKey()
 	if err != nil {
-		return &appError{err, "failed to read secret key", http.StatusInternalServerError}
+		return &appError{err, "{ \"message\": \"Failed to read secret key\" }",
+			http.StatusInternalServerError}
 	}
 	if err := handler.validateToken(request, adminKey); err != nil {
 		return err
 	}
 	if handler.findID(request) {
-		return &appError{errors.New("id not found"), "id not found", http.StatusNotFound}
+		return &appError{errors.New("ID not found"), "ID not found", http.StatusNotFound}
 	}
 	guestID, err := getID(request)
 	if err != nil {
-		return &appError{err, "failed to parse id", http.StatusInternalServerError}
+		return &appError{err, "{ \"message\": \"Failed to parse ID\" }",
+			http.StatusInternalServerError}
 	}
 	err = handler.store.Delete(int(guestID))
 	if err != nil {
-		return &appError{err, "failed to get guests", http.StatusInternalServerError}
+		return &appError{err, "{ \"message\": \"Failed to get guests\" }",
+			http.StatusInternalServerError}
 	}
 	return nil
 }
diff --git a/server/test/guest_test.go b/server/test/guest_test.go
index 5bb77ff..490df84 100644
--- a/server/test/guest_test.go
+++ b/server/test/guest_test.go
@@ -154,11 +154,11 @@ func assertEquals(test testing.TB, actual any, expected any) {
 }
 
 func getName() string {
-	return "{ \"firstName\": \"Michael\", \"lastName\": \"Hunteman\"}"
+	return "{ \"firstName\": \"Michael\", \"lastName\": \"Hunteman\" }"
 }
 
 func getCredentials() string {
-	return fmt.Sprintf("{ \"username\": \"mhunteman\", \"password\": \"%s\"}",
+	return fmt.Sprintf("{ \"username\": \"mhunteman\", \"password\": \"%s\" }",
 		os.Getenv("PASS"))
 }