Merge pull request #17 from hammercode-dev/be-09/custome-error

AfandyW · web-flow · commit 860e48a90b38 · 2025-06-10T11:56:53.000+08:00
[BE-09] - Custome Error
diff --git a/app/newsletters/delivery/http/newsletter.go b/app/newsletters/delivery/http/newsletter.go
@@ -32,7 +32,7 @@ func (h handler) Subscribe(w http.ResponseWriter, r *http.Request) {
 
 	err = h.usecase.Subscribe(r.Context(), payload.Email)
 	if err != nil {
-		resp := utils.CostumErr(err.Error())
+		resp := utils.CustomErrorResponse(err)
 		utils.Response(resp, w)
 		return
 	}
diff --git a/app/users/delivery/http/login_users.go b/app/users/delivery/http/login_users.go
@@ -23,25 +23,21 @@ import (
 func (h Handler) Login(w http.ResponseWriter, r *http.Request) {
 	bodyBytes, err := io.ReadAll(r.Body)
 	if err != nil {
-		utils.Response(domain.HttpResponse{
-			Code:    500,
-			Message: err.Error(),
-		}, w)
+		resp := utils.CustomErrorResponse(err)
+		utils.Response(resp, w)
 		return
 	}
 
 	loginInstance := domain.Login{}
 	if err := json.Unmarshal(bodyBytes, &loginInstance); err != nil {
-		utils.Response(domain.HttpResponse{
-			Code:    500,
-			Message: err.Error(),
-		}, w)
+		resp := utils.CustomErrorResponse(err)
+		utils.Response(resp, w)
 		return
 	}
 
 	_, token, err := h.usecase.Login(r.Context(), loginInstance)
 	if err != nil {
-		resp := utils.CostumErr(err.Error())
+		resp := utils.CustomErrorResponse(err)
 		utils.Response(resp, w)
 		return
 	}
diff --git a/app/users/delivery/http/logout_users.go b/app/users/delivery/http/logout_users.go
@@ -22,7 +22,7 @@ func (h Handler) Logout(w http.ResponseWriter, r *http.Request) {
 
 	err := h.usecase.Logout(r.Context(), *token)
 	if err != nil {
-		resp := utils.CostumErr(err.Error())
+		resp := utils.CustomErrorResponse(err)
 		utils.Response(resp, w)
 		return
 	}
diff --git a/app/users/delivery/http/register_users.go b/app/users/delivery/http/register_users.go
@@ -25,36 +25,30 @@ import (
 func (h Handler) Register(w http.ResponseWriter, r *http.Request) {
 	bodyBytes, err := io.ReadAll(r.Body)
 	if err != nil {
-		utils.Response(domain.HttpResponse{
-			Code:    500,
-			Message: err.Error(),
-		}, w)
+		resp := utils.CustomErrorResponse(err)
+		utils.Response(resp, w)
 		return
 	}
 
 	user := domain.Register{}
 	if err = json.Unmarshal(bodyBytes, &user); err != nil {
-		utils.Response(domain.HttpResponse{
-			Code:    500,
-			Message: err.Error(),
-		}, w)
+		resp := utils.CustomErrorResponse(err)
+		utils.Response(resp, w)
 		return
 	}
 
 	if user.Password != user.ConfirmPassword {
-		utils.Response(domain.HttpResponse{
-			Code:    400,
-			Message: "Confirm password doesnt match",
-			Data:    nil,
-		}, w)
+		err := utils.NewBadRequestError(r.Context(), "Confirm password doesn't match", nil)
+		resp := utils.CustomErrorResponse(err)
+		utils.Response(resp, w)
 		return
 	}
 
 	userInput := domain.RegistToUser(user)
 	_, err = h.usecase.Register(r.Context(), userInput)
 	if err != nil {
 		logrus.Error("userUsecase: failed to register user")
-		resp := utils.CostumErr(err.Error())
+		resp := utils.CustomErrorResponse(err)
 		utils.Response(resp, w)
 		return
 	}
diff --git a/app/users/usecase/login_users.go b/app/users/usecase/login_users.go
@@ -4,20 +4,20 @@ import (
 	"context"
 
 	"github.com/hammer-code/lms-be/domain"
-	"github.com/sirupsen/logrus"
+	"github.com/hammer-code/lms-be/utils"
 	"golang.org/x/crypto/bcrypt"
 )
 
 func (us *usecase) Login(ctx context.Context, userReq domain.Login) (user domain.User, token string, err error) {
 	err = us.dbTX.StartTransaction(ctx, func(txCtx context.Context) error {
 		user, err = us.userRepo.FindByEmail(ctx, userReq.Email)
 		if err != nil {
-			logrus.Error("us.LoginUser: failed to login", err)
+			err = utils.NewInternalServerError(ctx, err)
 			return err
 		}
 	
 		if err = bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(userReq.Password)); err != nil {
-			logrus.Error("us.Login: invalid password")
+			err = utils.NewBadRequestError(ctx, "Email or Password is invalid", err)
 			return err
 		}
 	
@@ -26,24 +26,24 @@ func (us *usecase) Login(ctx context.Context, userReq domain.Login) (user domain
 		token = *tokenPtr
 		
 		if err != nil {
-			logrus.Error("us.Login: failed to login. ", err)
+			err = utils.NewInternalServerError(ctx, err)
 			return err
 		}
 
 		if err = us.userRepo.UnactivateTokenByUser(ctx, user.ID); err != nil {
-			logrus.Error("us.Login: failed to login. ", err)
+			err = utils.NewInternalServerError(ctx, err)
 			return err
 		}
 		if err = us.userRepo.StoreToken(ctx, token, expiredTime, user.ID); err != nil {
-			logrus.Error("us.Login: failed to login. ", err)
+			err = utils.NewInternalServerError(ctx, err)
 			return err
 		}
 
 		return nil
 	})
 
 	if err != nil {
-		logrus.Error("us.Login: failed to login. ", err)
+		err = utils.NewInternalServerError(ctx, err)
 		return
 	}
 
diff --git a/app/users/usecase/logout_users.go b/app/users/usecase/logout_users.go
@@ -1,12 +1,22 @@
 package usecase
 
-import "context"
+import (
+	"context"
+
+	"github.com/hammer-code/lms-be/utils"
+)
 
 func (us *usecase) Logout(ctx context.Context, token string) error {
 	jwtData, err := us.jwt.VerifyToken(token)
 	if err != nil {
+		err = utils.NewInternalServerError(ctx, err)
 		return err
 	}
 
-	return us.userRepo.LogoutUser(ctx, token, jwtData.ExpiresAt.Time)
+	err = us.userRepo.LogoutUser(ctx, token, jwtData.ExpiresAt.Time)
+	if err != nil {
+		err = utils.NewInternalServerError(ctx, err)
+		return err
+	}
+	return err
 }
diff --git a/app/users/usecase/register_users.go b/app/users/usecase/register_users.go
@@ -5,32 +5,34 @@ import (
 
 	"github.com/hammer-code/lms-be/constants"
 	"github.com/hammer-code/lms-be/domain"
-	"github.com/sirupsen/logrus"
+	"github.com/hammer-code/lms-be/utils"
 	"golang.org/x/crypto/bcrypt"
 )
 
 func (us *usecase) Register(ctx context.Context, userReq domain.User) (domain.User, error) {
 	user := domain.User{}
-	if err := us.dbTX.StartTransaction(ctx, func(txCtx context.Context) error {
+	err := us.dbTX.StartTransaction(ctx, func(txCtx context.Context) error {
 		hashPassword, err := bcrypt.GenerateFromPassword([]byte(userReq.Password), bcrypt.DefaultCost)
 		if err != nil {
-			logrus.Error("us.Register: failed to register user", err)
+			err = utils.NewInternalServerError(ctx, err)
 			return err
 		}
 
 		userReq.Password = string(hashPassword)
 		userReq.Role = constants.RoleUser
 		user, err = us.userRepo.CreateUser(ctx, userReq)
 		if err != nil {
-			logrus.Error("us.Register: failed to register users. ", err)
-
+			err = utils.NewInternalServerError(ctx, err)
 			return err
 		}
 		return nil
 
-	}); err != nil {
-		logrus.Error("us.Register: failed to get users. ", err)
+	})
+
+	if err != nil {
+		err = utils.NewInternalServerError(ctx, err)
 		return domain.User{}, err
 	}
+	
 	return user, nil
 }
diff --git a/utils/costum_error.go b/utils/costum_error.go
@@ -1,14 +1,63 @@
 package utils
 
 import (
+	"context"
+	"fmt"
+	"net/http"
 	"strings"
 
 	"github.com/hammer-code/lms-be/domain"
+	"github.com/hammer-code/lms-be/pkg/ngelog"
 )
 
-func CheckError(err, sub, message string, code int) (domain.HttpResponse, bool) {
+const (
+	ErrDuplicateEmail 	 = "\"uni_users_email\" (SQLSTATE 23505)"
+	ErrWrongPassword  	 = "password"
+	ErrNotFoundSQL       = "sql: no rows in result set"
+)
+
+type CustomHttpError struct {
+	Code int
+	Message string
+	OriginError error
+}
+
+func (e *CustomHttpError) Error() string {
+	if e.OriginError != nil {
+		return fmt.Sprintf("%s: %s", e.Message, e.OriginError.Error())
+	}
+	return e.Message
+}
 
-	if strings.Contains(err, sub) {
+func NewBadRequestError(ctx context.Context, msg string, err error) *CustomHttpError {
+	ngelog.Error(ctx, msg, err)
+	return &CustomHttpError{
+		Code:    http.StatusBadRequest,
+		Message: msg,
+		OriginError: err,
+	}
+}
+
+func NewUnauthorizedError(ctx context.Context, msg string, err error) *CustomHttpError {
+	ngelog.Error(ctx, msg, err)
+	return &CustomHttpError{
+		Code:    http.StatusUnauthorized,
+		Message: msg,
+		OriginError: err,
+	}
+}
+
+func NewInternalServerError(ctx context.Context, err error) *CustomHttpError {
+	ngelog.Error(ctx, "Internal server error", err)
+	return &CustomHttpError{
+		Code:    http.StatusInternalServerError,
+		Message: "Internal server error",
+		OriginError: err,
+	}
+}
+
+func CheckError(errStr, containsStr, message string, code int) (domain.HttpResponse, bool) {
+	if strings.Contains(errStr, containsStr) {
 		return domain.HttpResponse{
 			Code:    code,
 			Message: message,
@@ -17,25 +66,35 @@ func CheckError(err, sub, message string, code int) (domain.HttpResponse, bool)
 	return domain.HttpResponse{}, false
 }
 
-func CostumErr(err string) domain.HttpResponse {
+func CustomErrorResponse(err error) domain.HttpResponse {
+	if customErr, ok := err.(*CustomHttpError); ok {
+		var errStr string
+		if customErr.OriginError != nil {
+			errStr = customErr.OriginError.Error()
+		}
+		resp, ok := CheckError(errStr, ErrDuplicateEmail, "User already exist", http.StatusBadRequest)
+		if ok {
+			return resp
+		}
 
-	resp, ok := CheckError(err, "\"uni_users_email\" (SQLSTATE 23505)", "User already exist", 400)
-	if ok {
-		return resp
-	}
+		resp, ok = CheckError(errStr, ErrWrongPassword, "Sorry, your password is incorrect", http.StatusBadRequest)
+		if ok {
+			return resp
+		}
 
-	resp, ok = CheckError(err, "\"uni_logout_token\" (SQLSTATE 23505)", "You have already logged out.", 400)
-	if ok {
-		return resp
-	}
+		resp, ok = CheckError(errStr, ErrNotFoundSQL, "Data not found", http.StatusNotFound)
+		if ok {
+			return resp
+		}
 
-	resp, ok = CheckError(err, "password", "Sorry, your password is incorrect", 400)
-	if ok {
-		return resp
+		return domain.HttpResponse{
+			Code:    customErr.Code,
+			Message: customErr.Message,
+		}
 	}
 
 	return domain.HttpResponse{
-		Code:    400,
+		Code:    http.StatusInternalServerError,
 		Message: "Internal server error",
 	}
 

Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ func (h handler) Subscribe(w http.ResponseWriter, r *http.Request) {`
`32`	`32`
`33`	`33`	`err = h.usecase.Subscribe(r.Context(), payload.Email)`
`34`	`34`	`if err != nil {`
`35`		`- resp := utils.CostumErr(err.Error())`
	`35`	`+ resp := utils.CustomErrorResponse(err)`
`36`	`36`	`utils.Response(resp, w)`
`37`	`37`	`return`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ func (h Handler) Logout(w http.ResponseWriter, r *http.Request) {`
`22`	`22`
`23`	`23`	`err := h.usecase.Logout(r.Context(), *token)`
`24`	`24`	`if err != nil {`
`25`		`- resp := utils.CostumErr(err.Error())`
	`25`	`+ resp := utils.CustomErrorResponse(err)`
`26`	`26`	`utils.Response(resp, w)`
`27`	`27`	`return`
`28`	`28`	`}`