Feat：Using Go to implement user registration logic (#13431)

### What problem does this PR solve?

Feat：Using Go to implement user registration logic

### Type of change

- [x] New Feature (non-breaking change which adds functionality)

internal/handler/chat.go

@@ -59,11 +59,11 @@ func (h *ChatHandler) ListChats(c *gin.Context) {
 	}
 
 	// Get user by access token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}
@@ -112,11 +112,11 @@ func (h *ChatHandler) ListChatsNext(c *gin.Context) {
 	}
 
 	// Get user by access token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}
@@ -196,11 +196,11 @@ func (h *ChatHandler) SetDialog(c *gin.Context) {
 	}
 
 	// Get user by access token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}
@@ -268,11 +268,11 @@ func (h *ChatHandler) RemoveChats(c *gin.Context) {
 	}
 
 	// Get user by access token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}

internal/handler/chat_session.go

@@ -61,11 +61,11 @@ func (h *ChatSessionHandler) SetChatSession(c *gin.Context) {
 	}
 
 	// Get user by access token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}
@@ -124,11 +124,11 @@ func (h *ChatSessionHandler) RemoveChatSessions(c *gin.Context) {
 	}
 
 	// Get user by access token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}
@@ -190,11 +190,11 @@ func (h *ChatSessionHandler) ListChatSessions(c *gin.Context) {
 	}
 
 	// Get user by access token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}
@@ -270,11 +270,11 @@ func (h *ChatSessionHandler) Completion(c *gin.Context) {
 	}
 
 	// Get user by access token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}

internal/handler/chunk.go

@@ -59,11 +59,11 @@ func (h *ChunkHandler) RetrievalTest(c *gin.Context) {
 	}
 
 	// Get user by access token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}

internal/handler/connector.go

@@ -58,11 +58,11 @@ func (h *ConnectorHandler) ListConnectors(c *gin.Context) {
 	}
 
 	// Get user by access token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}

internal/handler/file.go

@@ -65,11 +65,11 @@ func (h *FileHandler) ListFiles(c *gin.Context) {
 	}
 
 	// Get user by access token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}
@@ -141,11 +141,11 @@ func (h *FileHandler) GetRootFolder(c *gin.Context) {
 	}
 
 	// Get user by access token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}
@@ -189,11 +189,11 @@ func (h *FileHandler) GetParentFolder(c *gin.Context) {
 	}
 
 	// Get user by access token (for validation)
-	_, err := h.userService.GetUserByToken(token)
+	_, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}
@@ -246,11 +246,11 @@ func (h *FileHandler) GetAllParentFolders(c *gin.Context) {
 	}
 
 	// Get user by access token (for validation)
-	_, err := h.userService.GetUserByToken(token)
+	_, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}

internal/handler/kb.go

@@ -130,11 +130,11 @@ func (h *KnowledgebaseHandler) ListKbs(c *gin.Context) {
 	}
 
 	// Get user by access token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}

internal/handler/llm.go

@@ -71,10 +71,11 @@ func (h *LLMHandler) GetMyLLMs(c *gin.Context) {
 	}
 
 	// Get user by token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"error": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}
@@ -127,10 +128,11 @@ func (h *LLMHandler) Factories(c *gin.Context) {
 	}
 
 	// Get user by token
-	_, err := h.userService.GetUserByToken(token)
+	_, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"error": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}
@@ -207,11 +209,11 @@ func (h *LLMHandler) ListApp(c *gin.Context) {
 	}
 
 	// Get user by token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}

internal/handler/search.go

@@ -65,11 +65,11 @@ func (h *SearchHandler) ListSearchApps(c *gin.Context) {
 	}
 
 	// Get user by access token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}

internal/handler/tenant.go

@@ -58,10 +58,11 @@ func (h *TenantHandler) TenantInfo(c *gin.Context) {
 		return
 	}
 	// Get user by token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"error": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}
@@ -109,11 +110,11 @@ func (h *TenantHandler) TenantList(c *gin.Context) {
 	}
 
 	// Get user by token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
 		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+			"code":    code,
+			"message": err.Error(),
 		})
 		return
 	}

internal/handler/user.go

@@ -17,7 +17,9 @@
 package handler
 
 import (
+	"fmt"
 	"net/http"
+	"ragflow/internal/common"
 	"ragflow/internal/server"
 	"ragflow/internal/utility"
 	"strconv"
@@ -47,31 +49,51 @@ func NewUserHandler(userService *service.UserService) *UserHandler {
 // @Produce json
 // @Param request body service.RegisterRequest true "registration info"
 // @Success 200 {object} map[string]interface{}
-// @Router /api/v1/users/register [post]
+// @Router /v1/user/register [post]
 func (h *UserHandler) Register(c *gin.Context) {
 	var req service.RegisterRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": err.Error(),
+		c.JSON(http.StatusOK, gin.H{
+			"code":    common.CodeBadRequest,
+			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
 
-	user, err := h.userService.Register(&req)
+	user, code, err := h.userService.Register(&req)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": err.Error(),
+		c.JSON(http.StatusOK, gin.H{
+			"code":    code,
+			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
 
+	variables := server.GetVariables()
+	secretKey := variables.SecretKey
+	authToken, err := utility.DumpAccessToken(*user.AccessToken, secretKey)
+	if err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"code":    common.CodeServerError,
+			"message": "Failed to generate auth token",
+			"data":    false,
+		})
+		return
+	}
+
+	c.Header("Authorization", authToken)
+	c.Header("Access-Control-Allow-Origin", "*")
+	c.Header("Access-Control-Allow-Methods", "*")
+	c.Header("Access-Control-Allow-Headers", "*")
+	c.Header("Access-Control-Expose-Headers", "Authorization")
+
+	profile := h.userService.GetUserProfile(user)
 	c.JSON(http.StatusOK, gin.H{
-		"message": "registration successful",
-		"data": gin.H{
-			"id":       user.ID,
-			"nickname": user.Nickname,
-			"email":    user.Email,
-		},
+		"code":    common.CodeSuccess,
+		"message": fmt.Sprintf("%s, welcome aboard!", req.Nickname),
+		"data":    profile,
 	})
 }
 
@@ -87,18 +109,20 @@ func (h *UserHandler) Register(c *gin.Context) {
 func (h *UserHandler) Login(c *gin.Context) {
 	var req service.LoginRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"code":    400,
+		c.JSON(http.StatusOK, gin.H{
+			"code":    common.CodeBadRequest,
 			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
 
-	user, err := h.userService.Login(&req)
+	user, code, err := h.userService.Login(&req)
 	if err != nil {
-		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
+		c.JSON(http.StatusOK, gin.H{
+			"code":    code,
 			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
@@ -114,7 +138,7 @@ func (h *UserHandler) Login(c *gin.Context) {
 	c.Header("Access-Control-Expose-Headers", "Authorization")
 
 	c.JSON(http.StatusOK, gin.H{
-		"code":    0,
+		"code":    common.CodeSuccess,
 		"message": "Welcome back!",
 		"data":    user,
 	})
@@ -132,18 +156,20 @@ func (h *UserHandler) Login(c *gin.Context) {
 func (h *UserHandler) LoginByEmail(c *gin.Context) {
 	var req service.EmailLoginRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"code":    400,
+		c.JSON(http.StatusOK, gin.H{
+			"code":    common.CodeBadRequest,
 			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
 
-	user, err := h.userService.LoginByEmail(&req)
+	user, code, err := h.userService.LoginByEmail(&req)
 	if err != nil {
-		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
+		c.JSON(http.StatusOK, gin.H{
+			"code":    code,
 			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
@@ -151,21 +177,26 @@ func (h *UserHandler) LoginByEmail(c *gin.Context) {
 	variables := server.GetVariables()
 	secretKey := variables.SecretKey
 	authToken, err := utility.DumpAccessToken(*user.AccessToken, secretKey)
-
-	// Set Authorization header with access_token
-	if user.AccessToken != nil {
-		c.Header("Authorization", authToken)
+	if err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"code":    common.CodeServerError,
+			"message": "Failed to generate auth token",
+			"data":    false,
+		})
+		return
 	}
-	// Set CORS headers
+
+	c.Header("Authorization", authToken)
 	c.Header("Access-Control-Allow-Origin", "*")
 	c.Header("Access-Control-Allow-Methods", "*")
 	c.Header("Access-Control-Allow-Headers", "*")
 	c.Header("Access-Control-Expose-Headers", "Authorization")
 
+	profile := h.userService.GetUserProfile(user)
 	c.JSON(http.StatusOK, gin.H{
-		"code":    0,
+		"code":    common.CodeSuccess,
 		"message": "Welcome back!",
-		"data":    user,
+		"data":    profile,
 	})
 }
 
@@ -182,22 +213,28 @@ func (h *UserHandler) GetUserByID(c *gin.Context) {
 	idStr := c.Param("id")
 	id, err := strconv.ParseUint(idStr, 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": "invalid user id",
+		c.JSON(http.StatusOK, gin.H{
+			"code":    common.CodeBadRequest,
+			"message": "invalid user id",
+			"data":    false,
 		})
 		return
 	}
 
-	user, err := h.userService.GetUserByID(uint(id))
+	user, code, err := h.userService.GetUserByID(uint(id))
 	if err != nil {
-		c.JSON(http.StatusNotFound, gin.H{
-			"error": "user not found",
+		c.JSON(http.StatusOK, gin.H{
+			"code":    code,
+			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
 
 	c.JSON(http.StatusOK, gin.H{
-		"data": user,
+		"code":    common.CodeSuccess,
+		"message": "success",
+		"data":    user,
 	})
 }
 
@@ -222,15 +259,19 @@ func (h *UserHandler) ListUsers(c *gin.Context) {
 		pageSize = 10
 	}
 
-	users, total, err := h.userService.ListUsers(page, pageSize)
+	users, total, code, err := h.userService.ListUsers(page, pageSize)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "failed to get users",
+		c.JSON(http.StatusOK, gin.H{
+			"code":    code,
+			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
 
 	c.JSON(http.StatusOK, gin.H{
+		"code":    common.CodeSuccess,
+		"message": "success",
 		"data": gin.H{
 			"items":     users,
 			"total":     total,
@@ -253,34 +294,38 @@ func (h *UserHandler) Logout(c *gin.Context) {
 	// Extract token from request
 	token := c.GetHeader("Authorization")
 	if token == "" {
-		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
+		c.JSON(http.StatusOK, gin.H{
+			"code":    common.CodeUnauthorized,
 			"message": "Missing Authorization header",
+			"data":    false,
 		})
 		return
 	}
 
 	// Get user by token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
-		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
-			"message": "Invalid access token",
+		c.JSON(http.StatusOK, gin.H{
+			"code":    code,
+			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
 
 	// Logout user
-	if err := h.userService.Logout(user); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"code":    500,
+	code, err = h.userService.Logout(user)
+	if err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"code":    code,
 			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
 
 	c.JSON(http.StatusOK, gin.H{
-		"code":    0,
+		"code":    common.CodeSuccess,
 		"data":    true,
 		"message": "success",
 	})
@@ -299,19 +344,21 @@ func (h *UserHandler) Info(c *gin.Context) {
 	// Extract token from request
 	token := c.GetHeader("Authorization")
 	if token == "" {
-		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
+		c.JSON(http.StatusOK, gin.H{
+			"code":    common.CodeUnauthorized,
 			"message": "Missing Authorization header",
+			"data":    false,
 		})
 		return
 	}
 
 	// Get user by token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
-		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":  401,
-			"error": "Invalid access token",
+		c.JSON(http.StatusOK, gin.H{
+			"code":    code,
+			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
@@ -320,8 +367,9 @@ func (h *UserHandler) Info(c *gin.Context) {
 	profile := h.userService.GetUserProfile(user)
 
 	c.JSON(http.StatusOK, gin.H{
-		"code": 0,
-		"data": profile,
+		"code":    common.CodeSuccess,
+		"message": "success",
+		"data":    profile,
 	})
 }
 
@@ -339,18 +387,21 @@ func (h *UserHandler) Setting(c *gin.Context) {
 	// Extract token from request
 	token := c.GetHeader("Authorization")
 	if token == "" {
-		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
+		c.JSON(http.StatusOK, gin.H{
+			"code":    common.CodeUnauthorized,
 			"message": "Missing Authorization header",
+			"data":    false,
 		})
 		return
 	}
 
 	// Get user by token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
-		c.JSON(http.StatusUnauthorized, gin.H{
-			"error": "Invalid access token",
+		c.JSON(http.StatusOK, gin.H{
+			"code":    code,
+			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
@@ -358,22 +409,29 @@ func (h *UserHandler) Setting(c *gin.Context) {
 	// Parse request
 	var req service.UpdateSettingsRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": err.Error(),
+		c.JSON(http.StatusOK, gin.H{
+			"code":    common.CodeBadRequest,
+			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
 
 	// Update user settings
-	if err := h.userService.UpdateUserSettings(user, &req); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": err.Error(),
+	code, err = h.userService.UpdateUserSettings(user, &req)
+	if err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"code":    code,
+			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
 
 	c.JSON(http.StatusOK, gin.H{
+		"code":    common.CodeSuccess,
 		"message": "settings updated successfully",
+		"data":    true,
 	})
 }
 
@@ -391,18 +449,21 @@ func (h *UserHandler) ChangePassword(c *gin.Context) {
 	// Extract token from request
 	token := c.GetHeader("Authorization")
 	if token == "" {
-		c.JSON(http.StatusUnauthorized, gin.H{
-			"code":    401,
+		c.JSON(http.StatusOK, gin.H{
+			"code":    common.CodeUnauthorized,
 			"message": "Missing Authorization header",
+			"data":    false,
 		})
 		return
 	}
 
 	// Get user by token
-	user, err := h.userService.GetUserByToken(token)
+	user, code, err := h.userService.GetUserByToken(token)
 	if err != nil {
-		c.JSON(http.StatusUnauthorized, gin.H{
-			"error": "Invalid access token",
+		c.JSON(http.StatusOK, gin.H{
+			"code":    code,
+			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
@@ -410,22 +471,29 @@ func (h *UserHandler) ChangePassword(c *gin.Context) {
 	// Parse request
 	var req service.ChangePasswordRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": err.Error(),
+		c.JSON(http.StatusOK, gin.H{
+			"code":    common.CodeBadRequest,
+			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
 
 	// Change password
-	if err := h.userService.ChangePassword(user, &req); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": err.Error(),
+	code, err = h.userService.ChangePassword(user, &req)
+	if err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"code":    code,
+			"message": err.Error(),
+			"data":    false,
 		})
 		return
 	}
 
 	c.JSON(http.StatusOK, gin.H{
+		"code":    common.CodeSuccess,
 		"message": "password changed successfully",
+		"data":    true,
 	})
 }
 
@@ -438,10 +506,10 @@ func (h *UserHandler) ChangePassword(c *gin.Context) {
 // @Success 200 {object} map[string]interface{}
 // @Router /v1/user/login/channels [get]
 func (h *UserHandler) GetLoginChannels(c *gin.Context) {
-	channels, err := h.userService.GetLoginChannels()
+	channels, code, err := h.userService.GetLoginChannels()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"code":    500,
+		c.JSON(http.StatusOK, gin.H{
+			"code":    code,
 			"message": "Load channels failure, error: " + err.Error(),
 			"data":    []interface{}{},
 		})
@@ -449,7 +517,7 @@ func (h *UserHandler) GetLoginChannels(c *gin.Context) {
 	}
 
 	c.JSON(http.StatusOK, gin.H{
-		"code":    0,
+		"code":    common.CodeSuccess,
 		"message": "success",
 		"data":    channels,
 	})