Approriate error messages on failures

api/auth/auth.go

@@ -42,11 +42,14 @@ func GeneratePasswordHash(password string) ([]byte, error) {
 }
 
 func ValidatePassword(hash []byte, password string) error {
-	return bcrypt.CompareHashAndPassword(hash, []byte(password))
+	err := bcrypt.CompareHashAndPassword(hash, []byte(password))
+	if errors.Is(err, bcrypt.ErrMismatchedHashAndPassword) {
+		return &ErrPasswordDidNotMatch
+	}
+	return err
 }
 
 func CreateToken(userId int) (string, error) {
-	//TODO check
 	claims := CustomClaims{
 		userId,
 		jwt.StandardClaims{
@@ -73,16 +76,26 @@ func ValidateToken(tokenString string) (userId int, err error) {
 		return PubKey, nil
 	})
 
-	if err != nil {
+	if ve, ok := err.(*jwt.ValidationError); !token.Valid && ok {
+		authError := AuthenticationError{"unknown reason"}
+		if ve.Errors&jwt.ValidationErrorExpired != 0 {
+			authError = ErrTokenExpired
+		} else if ve.Errors&jwt.ValidationErrorMalformed != 0 {
+			authError = AuthenticationError{"not a token string: " + tokenString}
+		}
+		log.Printf("authentication failed (%v) for token %v", authError.reason, tokenString)
+		return 0, &authError
+	} else if !ok {
+		// not a validation error
 		return 0, err
 	}
 
-	if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
+	if claims, ok := token.Claims.(jwt.MapClaims); ok {
 		// All claim values seems to be float. So we must convert to int after assertion to float
 		userId = int(claims["UserId"].(float64))
 		log.Printf("authentication complete for user %v", userId)
 	} else {
-		return 0, errors.New("get user_id failed")
+		return 0, errors.New("failed to get user id from token")
 	}
 
 	return userId, nil

api/auth/error.go

@@ -0,0 +1,12 @@
+package auth
+
+type AuthenticationError struct {
+	reason string
+}
+
+func (e *AuthenticationError) Error() string {
+	return "authentication failure: " + e.reason
+}
+
+var ErrPasswordDidNotMatch = AuthenticationError{"password did not match"}
+var ErrTokenExpired = AuthenticationError{"token has expired"}

api/controller/follow.go

@@ -1,6 +1,7 @@
 package controller
 
 import (
+	"fmt"
 	"net/http"
 	"strconv"
 
@@ -17,19 +18,22 @@ type Follow struct {
 func ShowFollow(c *gin.Context) {
 	target, err := strconv.ParseUint(c.Param("id"), 0, 64)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		e := fmt.Sprintf("failed to cummunicate with the database: %v", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"error": e})
 		return
 	}
 
 	srcUserId, ok := c.MustGet("userId").(int)
 	if !ok {
-		c.JSON(http.StatusInternalServerError, "invalid user id")
+		e := fmt.Sprintf("invalid user id: %v", c.MustGet("userId"))
+		c.JSON(http.StatusInternalServerError, gin.H{"error": e})
 		return
 	}
 
 	response, err := getFollowFromDB(uint(srcUserId), uint(target))
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, err.Error())
+		e := fmt.Sprintf("failed to cummunicate with the database: %v", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"error": e})
 		return
 	}
 
@@ -39,25 +43,30 @@ func ShowFollow(c *gin.Context) {
 func FollowUser(c *gin.Context) {
 	destUserId, err := strconv.ParseUint(c.Param("id"), 0, 64)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		e := fmt.Sprintf("failed to cummunicate with the database: %v", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"error": e})
 		return
 	}
 
 	srcUserId, ok := c.MustGet("userId").(int)
 	if !ok {
-		c.JSON(http.StatusInternalServerError, "invalid user id")
+		e := fmt.Sprintf("invalid user id: %v", c.MustGet("userId"))
+		c.JSON(http.StatusInternalServerError, gin.H{"error": e})
 		return
 	}
 
 	_, err = db.CreateFollow(uint(srcUserId), uint(destUserId))
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, err.Error())
+		e := fmt.Sprintf("failed to cummunicate with the database: %v", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"error": e})
+
 		return
 	}
 
 	response, err := getFollowFromDB(uint(srcUserId), uint(destUserId))
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, err.Error())
+		e := fmt.Sprintf("failed to cummunicate with the database: %v", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"error": e})
 		return
 	}
 
@@ -67,25 +76,29 @@ func FollowUser(c *gin.Context) {
 func UnfollowUser(c *gin.Context) {
 	destUserId, err := strconv.ParseUint(c.Param("id"), 0, 64)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		e := fmt.Sprintf("failed to cummunicate with the database: %v", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"error": e})
 		return
 	}
 
 	srcUserId, ok := c.MustGet("userId").(int)
 	if !ok {
-		c.JSON(http.StatusInternalServerError, "invalid user id")
+		e := fmt.Sprintf("invalid user id: %v", c.MustGet("userId"))
+		c.JSON(http.StatusInternalServerError, gin.H{"error": e})
 		return
 	}
 
 	err = db.DestroyFollow(uint(srcUserId), uint(destUserId))
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, err.Error())
+		e := fmt.Sprintf("failed to cummunicate with the database: %v", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"error": e})
 		return
 	}
 
 	response, err := getFollowFromDB(uint(srcUserId), uint(destUserId))
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, err.Error())
+		e := fmt.Sprintf("failed to cummunicate with the database: %v", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"error": e})
 		return
 	}
 
@@ -99,19 +112,22 @@ type Followees struct {
 func ShowFollowees(c *gin.Context) {
 	source, ok := c.MustGet("userId").(int)
 	if !ok {
-		c.JSON(http.StatusInternalServerError, "invalid user id")
+		e := fmt.Sprintf("invalid user id: %v", c.MustGet("userId"))
+		c.JSON(http.StatusBadRequest, gin.H{"error": e})
 		return
 	}
 
 	followings, err := db.GetFollowing(uint(source))
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, err.Error())
+		e := fmt.Sprintf("failed to cummunicate with the database: %v", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"error": e})
 		return
 	}
 
 	followees, err := follows2users(followings, true)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, err.Error())
+		e := fmt.Sprintf("failed to cummunicate with the database: %v", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"error": e})
 		return
 	}
 
@@ -129,19 +145,22 @@ type Followers struct {
 func ShowFollowers(c *gin.Context) {
 	source, ok := c.MustGet("userId").(int)
 	if !ok {
-		c.JSON(http.StatusInternalServerError, "invalid user id")
+		e := fmt.Sprintf("invalid user id: %v", c.MustGet("userId"))
+		c.JSON(http.StatusBadRequest, gin.H{"error": e})
 		return
 	}
 
 	followeds, err := db.GetFollowed(uint(source))
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, err.Error())
+		e := fmt.Sprintf("failed to cummunicate with the database: %v", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"error": e})
 		return
 	}
 
 	followers, err := follows2users(followeds, false)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, err.Error())
+		e := fmt.Sprintf("failed to cummunicate with the database: %v", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"error": e})
 		return
 	}
 
@@ -164,9 +183,9 @@ func getFollowFromDB(source, target uint) (Follow, error) {
 	}
 
 	return Follow{
-		Target: target,
+		Target:    target,
 		Following: following,
-		Followed: followed,
+		Followed:  followed,
 	}, nil
 }
 
@@ -193,4 +212,4 @@ func follows2users(follows []db.Follow, forDest bool) ([]User, error) {
 	}
 
 	return users, nil
-}
+}

api/controller/matching.go

@@ -1,6 +1,7 @@
 package controller
 
 import (
+	"fmt"
 	"math/rand"
 	"net/http"
 
@@ -16,13 +17,15 @@ type MatchResponse struct {
 func MakeMatch(c *gin.Context) {
 	userId, ok := c.MustGet("userId").(int)
 	if !ok {
-		c.JSON(http.StatusInternalServerError, "invalid user id")
+		e := fmt.Sprintf("invalid user id: %v", c.MustGet("userId"))
+		c.JSON(http.StatusBadRequest, gin.H{"error": e})
 		return
 	}
 
 	targetUsers, err := getMatchUsers(uint(userId))
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		e := fmt.Sprintf("failed to cummunicate with the database: %v", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"error": e})
 		return
 	}
 
@@ -35,7 +38,8 @@ func MakeMatch(c *gin.Context) {
 
 	rawChatroom, err := db.CreateRoom([]uint{uint(userId), matchedUser.ID})
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		e := fmt.Sprintf("failed to cummunicate with the database: %v", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"error": e})
 		return
 	}
 	chatroom := fromDBRoom(rawChatroom)