Merge branch 'development' of github.com:hammercode-dev/lms-be into BE-10/Database-migrate-and-seeder

Author: Kocannn

.github/workflows/development.yml

@@ -11,12 +11,12 @@ jobs:
 
         steps:
             - name: Checkout Code
-              uses: actions/checkout@v2
+              uses: actions/checkout@v4
 
             - name: Set up Go
-              uses: actions/setup-go@v2
+              uses: actions/setup-go@v5
               with:
-                  go-version: '1.20'
+                  go-version: '1.24'
 
             - name: Test
               run: go test -v ./...
@@ -28,7 +28,7 @@ jobs:
               run: tar -czvf main.tar.gz main
 
             - name: Upload Artifact
-              uses: actions/upload-artifact@v3
+              uses: actions/upload-artifact@v4
               with:
                 name: build-artifact
                 path: main.tar.gz
@@ -39,10 +39,10 @@ jobs:
         environment: development
         steps:
             - name: Checkout Code
-              uses: actions/checkout@v2
+              uses: actions/checkout@v4
 
             - name: Download Build Artifact
-              uses: actions/download-artifact@v3
+              uses: actions/download-artifact@v4
               with:
                 name: build-artifact
 

app/middlewares/auth_middleware.go

@@ -5,64 +5,82 @@ import (
 	"strconv"
 
 	"github.com/hammer-code/lms-be/domain"
+	"github.com/hammer-code/lms-be/pkg/ngelog"
 	"github.com/hammer-code/lms-be/utils"
 )
 
 func (m *Middleware) AuthMiddleware(allowedRole string) domain.MiddlewareFunc {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
+			ctx, span := tracer.Start(request.Context(), "auth middleware")
+			defer span.End()
+
 			token := utils.ExtractBearerToken(request)
 			if len(*token) < 5 {
+				ngelog.Error(ctx, "failed to extract bearer token", nil)
 				utils.Response(domain.HttpResponse{
 					Code:    401,
 					Message: "Unauthorized",
 					Data:    nil,
 				}, writer)
 				return
 			}
-	
+
 			verifyToken, err := m.Jwt.VerifyToken(*token)
 			if err != nil {
+				ngelog.Error(ctx, "failed to verify token", err)
 				utils.Response(domain.HttpResponse{
 					Code:    500,
 					Message: "failed to verify token",
 					Data:    nil,
 				}, writer)
 				return
 			}
-	
-			// tokenLogoutErr := m.UserRepo.ExpiredToken(request.Context(), *token)
-			// if tokenLogoutErr == nil {
-			// 	utils.Response(domain.HttpResponse{
-			// 		Code:    401,
-			// 		Message: "Token expired",
-			// 		Data:    nil,
-			// 	}, writer)
-			// 	return
-			// }
-	
+
+			logoutToken, err := m.UserRepo.GetToken(request.Context(), *token)
+			if err != nil {
+				ngelog.Error(ctx, "failed to get token", err)
+				utils.Response(domain.HttpResponse{
+					Code:    401,
+					Message: "Unauthorized",
+					Data:    nil,
+				}, writer)
+				return
+			}
+			if logoutToken.Status == 0 {
+				ngelog.Error(ctx, "unauthorized", nil)
+				utils.Response(domain.HttpResponse{
+					Code:    401,
+					Message: "Unauthorized",
+					Data:    nil,
+				}, writer)
+				return
+			}
+
 			user, err := m.UserRepo.FindByEmail(request.Context(), verifyToken.Email)
 			if err != nil {
+				ngelog.Error(ctx, "failed to find by email", err)
 				utils.Response(domain.HttpResponse{
 					Code:    401,
 					Message: "Unauthorized",
 					Data:    nil,
 				}, writer)
 				return
 			}
-	
+
 			if user.Role != allowedRole {
+				ngelog.Error(ctx, "role is not the role", nil)
 				utils.Response(domain.HttpResponse{
 					Code:    401,
 					Message: "Unauthorized",
 					Data:    nil,
 				}, writer)
 				return
 			}
-	
+
 			writer.Header().Set("x-user-id", strconv.Itoa(user.ID))
 			writer.Header().Set("x-username", user.Username)
-	
+
 			next.ServeHTTP(writer, request)
 		})
 	}

app/middlewares/log.go

@@ -1,26 +1,23 @@
 package middlewares
 
 import (
-	"fmt"
 	"net/http"
-	"time"
-
-	"github.com/sirupsen/logrus"
 )
 
 func (m *Middleware) LogMiddleware(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		fmt.Println("hiteed")
-		start := time.Now()
+		ctx, span := tracer.Start(r.Context(), "HTTP "+r.Method+" "+r.URL.Path)
+		defer span.End()
+
+		// Replace request context with the new one
+		r = r.WithContext(ctx)
 
 		// Call the next handler
 		next.ServeHTTP(w, r)
-
-		// Log request details with Logrus
-		logrus.WithFields(logrus.Fields{
-			"method":   r.Method,
-			"url":      r.URL.Path,
-			"duration": time.Since(start).String(),
-		}).Info("Request processed")
+		// ngelog.Info(ctx, "request process", ngelog.AddFields{
+		// 	"method":   r.Method,
+		// 	"url":      r.URL.Path,
+		// 	"duration": time.Since(time.Now()).String(),
+		// })
 	})
 }

app/middlewares/middleware.go

@@ -3,13 +3,18 @@ package middlewares
 import (
 	"github.com/hammer-code/lms-be/domain"
 	"github.com/hammer-code/lms-be/pkg/jwt"
+	"go.opentelemetry.io/otel"
 )
 
 type Middleware struct {
 	Jwt      jwt.JWT
 	UserRepo domain.UserRepository
 }
 
+var (
+	tracer = otel.Tracer("Start Trace")
+)
+
 func InitMiddleware(jwt jwt.JWT, userRepo domain.UserRepository) domain.Middleware {
 	return &Middleware{
 		Jwt:      jwt,

app/users/delivery/http/logout_users.go

@@ -22,11 +22,8 @@ func (h Handler) Logout(w http.ResponseWriter, r *http.Request) {
 
 	err := h.usecase.Logout(r.Context(), *token)
 	if err != nil {
-		utils.Response(domain.HttpResponse{
-			Code:    500,
-			Message: err.Error(),
-			Data:    nil,
-		}, w)
+		resp := utils.CostumErr(err.Error())
+		utils.Response(resp, w)
 		return
 	}
 

app/users/repository/cleanup_logout_token.go

@@ -0,0 +1,17 @@
+package repository
+
+import (
+	"context"
+	"time"
+
+	"github.com/hammer-code/lms-be/domain"
+)
+
+func (repo *repository) CleanupLogoutToken(ctx context.Context) error {
+	token := &domain.LogoutToken{}
+	if err := repo.db.DB(ctx).Delete(token, "expired_at < ?", time.Now()).Error; err != nil {
+		return err
+	}
+
+	return nil
+}

app/users/repository/expired_token.go

@@ -0,0 +1,14 @@
+package repository
+
+import (
+	"context"
+
+	"github.com/hammer-code/lms-be/domain"
+)
+
+func (repo *repository) GetToken(ctx context.Context, token string) (logoutToken domain.LogoutToken, err error) {
+	if err = repo.db.DB(ctx).Find(&logoutToken, "token = ?", token).Error; err != nil {
+		return
+	}
+	return
+}

app/users/repository/get_token.go

@@ -2,18 +2,13 @@ package repository
 
 import (
 	"context"
-	"github.com/hammer-code/lms-be/domain"
 	"time"
+
+	"github.com/hammer-code/lms-be/domain"
 )
 
 func (repo *repository) LogoutUser(ctx context.Context, token string, expiredAt time.Time) error {
-	err := repo.db.DB(ctx).Create(&domain.LogoutToken{
-		Token:     token,
-		ExpiredAt: expiredAt,
-		CreatedAt: time.Now(),
-	}).Error
-
-	if err != nil {
+	if err := repo.db.DB(ctx).Model(&domain.LogoutToken{}).Where("token = ?", token).Update("status", 0).Error; err != nil {
 		return err
 	}
 

app/users/repository/logout_users.go

@@ -0,0 +1,24 @@
+package repository
+
+import (
+	"context"
+	"time"
+
+	"github.com/hammer-code/lms-be/domain"
+)
+
+func (repo *repository) StoreToken(ctx context.Context, token string, expiredAt time.Time, uid int) error {
+	err := repo.db.DB(ctx).Create(&domain.LogoutToken{
+		Token:     token,
+		ExpiredAt: expiredAt,
+		CreatedAt: time.Now(),
+		UserId:    uid,
+		Status:    1,
+	}).Error
+
+	if err != nil {
+		return err
+	}
+
+	return nil
+}