Revert "update 优化代码"

This reverts commit 33a81d8fdce09735347d2c3f64c954b1bda6bd1f.

game/config/data/codeConfig.json

@@ -12,19 +12,5 @@
   {"code":303,"message":"角色名已存在"},
   {"code":304,"message":"角色创建失败"},
   {"code":305,"message":"角色未登录"},
-  {"code":306,"message":"角色id错误"},
-  {"code":16001,"message":"参数错误"},
-  {"code":16002,"message":"内部错误"},
-  {"code":16003,"message":"用户被禁用"},
-  {"code":16004,"message":"用户名或者密码错误"},
-  {"code":16005,"message":"帐号已存在"},
-  {"code":16006,"message":"角色名称已存在"},
-  {"code":16007,"message":"角色不存在"},
-  {"code":16008,"message":"权限不存在"},
-  {"code":16009,"message":"权限已存在"},
-  {"code":16010,"message":"权限已被角色使用，无法删除"},
-  {"code":16011,"message":"没有权限"},
-  {"code":16012,"message":"角色不存在,或者已经被禁用"},
-  {"code":16013,"message":"管理员不存在"},
-  {"code":16014,"message":"admin-超级账户不能修改角色"}
+  {"code":306,"message":"角色id错误"}
 ]

game/game_cluster/internal/code/code.go

@@ -31,21 +31,4 @@ var (
 	TonWallAlreadyExistsError   int32 = 10311 // tonwall已绑定账号
 	NotEnoughItemsError         int32 = 10312 //物品不够
 	TonWallNotExistsError       int32 = 10313 // 未绑定钱包
-
-	// webadmin
-	ParamError                      int32 = 16001 // 参数错误
-	InternalError                   int32 = 16002 // 内部错误
-	DisabledUserError               int32 = 16003 // 用户被禁用
-	UserNameOrPasswordError         int32 = 16004 // 用户名或者密码错误
-	AccountExistError               int32 = 16005 // 帐号已存在
-	RoleNameExistError              int32 = 16006 // 角色名称已存在
-	RoleNotExistError               int32 = 16007 // 角色不存在
-	AccessNotExistError             int32 = 16008 // 权限不存在
-	AccessExistError                int32 = 16009 // 权限已存在
-	AccessHasUsedError              int32 = 16010 // 权限已被角色使用，无法删除
-	NoAccessError                   int32 = 16011 // 没有权限
-	RoleNotExistOrDisabledUserError int32 = 16012 // 角色不存在,或者已经被禁用
-	AdminNotExistError              int32 = 16013 // 管理员不存在
-	AdminMustNotUpdateError         int32 = 16014 // admin-超级账户不能修改角色
-
 )

game/game_cluster/nodes/webadmin/common/packResponse.go

@@ -1,30 +0,0 @@
-package common
-
-import (
-	"net/http"
-
-	"github.com/gin-gonic/gin"
-	"github.com/mhaya/game/game_cluster/internal/code"
-)
-
-func NewResult(statusCode int32) *code.Result {
-	result := &code.Result{
-		Code:    statusCode,
-		Message: code.GetMessage(statusCode),
-	}
-
-	return result
-}
-
-func PackOkResult(c *gin.Context, statusCode int32, data ...interface{}) {
-	result := &code.Result{
-		Code:    statusCode,
-		Message: code.GetMessage(statusCode),
-	}
-
-	if len(data) > 0 {
-		result.Data = data
-	}
-
-	c.JSON(http.StatusOK, result)
-}

game/game_cluster/nodes/webadmin/controller/admin.go

@@ -1,9 +1,9 @@
 package controller
 
 import (
+	"net/http"
+
 	"github.com/gin-gonic/gin"
-	"github.com/mhaya/game/game_cluster/internal/code"
-	"github.com/mhaya/game/game_cluster/nodes/webadmin/common"
 	"github.com/mhaya/game/game_cluster/nodes/webadmin/entity"
 	"github.com/mhaya/game/game_cluster/nodes/webadmin/service"
 )
@@ -22,99 +22,146 @@ func NewAdmin() *Admin {
 func (a *Admin) Login(ctx *gin.Context) {
 	var req entity.AdminLoginReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
 	resp, err := a.sev.Login(ctx, req.Username, req.Password)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, resp)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+		"data": resp,
+	})
 }
 
 // Add 添加管理员
 func (a *Admin) Add(ctx *gin.Context) {
 	var req entity.AdminAddReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
 	err := a.sev.Add(ctx, req.Username, req.Password, req.RealName, req.Pid, req.RoleId, req.Status)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, nil)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+	})
 }
 
 // ChangePassword 修改密码
 func (a *Admin) ChangePassword(ctx *gin.Context) {
 	var req entity.AdminChangePasswordReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
 	err := a.sev.ChangePassword(ctx, req.Username, req.Password)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, nil)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+	})
 }
 
 // Del 删除管理员
 func (a *Admin) Del(ctx *gin.Context) {
 	var req entity.AdminDelReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
 	err := a.sev.Delete(ctx, req.Username)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, nil)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+	})
 }
 
 // FindAll 获取所有管理员
 func (a *Admin) FindAll(ctx *gin.Context) {
 	var req entity.AdminFindAllReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 	}
 
-	resp, err := a.sev.FindAll(ctx, req.Page, req.Size, req.Username)
+	resp, total, err := a.sev.FindAll(ctx, req.Page, req.Size, req.Username)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, resp)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code":  200,
+		"msg":   "success",
+		"data":  resp,
+		"total": total,
+	})
 }
 
 func (a *Admin) UpdateStatus(ctx *gin.Context) {
 	var req entity.AdminUpdateStatusReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 	}
-
 	err := a.sev.UpdateStatus(ctx, req.Username, req.Status)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+	})
 
-	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // GetServerStatus
@@ -122,9 +169,16 @@ func (a *Admin) UpdateStatus(ctx *gin.Context) {
 func (a *Admin) GetServerStatus(ctx *gin.Context) {
 	resp, err := a.sev.GetServerStatus(ctx)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+		"data": resp,
+	})
 
-	common.PackOkResult(ctx, code.OK, resp)
 }

game/game_cluster/nodes/webadmin/controller/role.go

@@ -1,21 +1,18 @@
 package controller
 
 import (
+	"net/http"
+
 	"github.com/gin-gonic/gin"
-	"github.com/mhaya/game/game_cluster/internal/code"
-	"github.com/mhaya/game/game_cluster/nodes/webadmin/common"
 	"github.com/mhaya/game/game_cluster/nodes/webadmin/entity"
 	"github.com/mhaya/game/game_cluster/nodes/webadmin/service"
 )
 
 type Role struct {
-	sev *service.Role
 }
 
 func NewRole() *Role {
-	return &Role{
-		sev: service.NewRole(),
-	}
+	return &Role{}
 }
 
 // Add 新增角色
@@ -28,19 +25,26 @@ func NewRole() *Role {
 // @Success 200 {object} entity.Response
 // @Router /v1/admin/role/add [post]
 func (r *Role) Add(ctx *gin.Context) {
-	var req entity.RoleAddReq
+	req := new(entity.RoleAddReq)
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	err := r.sev.Add(ctx, req)
+	err := new(service.Role).Add(ctx, *req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, nil)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+	})
 }
 
 // List 角色列表
@@ -53,19 +57,28 @@ func (r *Role) Add(ctx *gin.Context) {
 // @Success 200 {object} entity.Response
 // @Router /v1/admin/role/list [get]
 func (r *Role) List(ctx *gin.Context) {
-	var req entity.RoleListReq
+	req := new(entity.RoleListReq)
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	resp, err := r.sev.List(ctx, req)
+	list, err := new(service.Role).List(ctx, req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, resp)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code":  200,
+		"msg":   "success",
+		"data":  list,
+		"count": req.Count,
+	})
 }
 
 // Update 修改角色
@@ -78,19 +91,26 @@ func (r *Role) List(ctx *gin.Context) {
 // @Success 200 {object} entity.Response
 // @Router /v1/admin/role/update [post]
 func (r *Role) Update(ctx *gin.Context) {
-	var req entity.RoleUpdateReq
+	req := new(entity.RoleUpdateReq)
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	err := r.sev.Update(ctx, req)
+	err := new(service.Role).Update(ctx, *req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, nil)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+	})
 }
 
 // Del 删除角色
@@ -103,19 +123,26 @@ func (r *Role) Update(ctx *gin.Context) {
 // @Success 200 {object} entity.Response
 // @Router /v1/admin/role/del [get]
 func (r *Role) Del(ctx *gin.Context) {
-	var req entity.RoleDelReq
+	req := new(entity.RoleDelReq)
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	err := r.sev.Del(ctx, req)
+	err := new(service.Role).Del(ctx, *req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, nil)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+	})
 }
 
 // AddRoleAccess  添加角色权限
@@ -128,19 +155,26 @@ func (r *Role) Del(ctx *gin.Context) {
 // @Success 200 {object} entity.Response
 // @Router /v1/admin/role/role_access/add [post]
 func (r *Role) AddRoleAccess(ctx *gin.Context) {
-	var req entity.RoleAccessAddReq
+	req := new(entity.RoleAccessAddReq)
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	err := r.sev.AddRoleAccess(ctx, req)
+	err := new(service.Role).AddRoleAccess(ctx, *req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, nil)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+	})
 }
 
 // UpdateRoleAccess 修改角色权限
@@ -153,19 +187,26 @@ func (r *Role) AddRoleAccess(ctx *gin.Context) {
 // @Success 200 {object} entity.Response
 // @Router /v1/admin/role/role_access/update [post]
 func (r *Role) UpdateRoleAccess(ctx *gin.Context) {
-	var req entity.RoleAccessUpdateReq
+	req := new(entity.RoleAccessUpdateReq)
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	err := r.sev.UpdateRoleAccess(ctx, req)
+	err := new(service.Role).UpdateRoleAccess(ctx, *req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, nil)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+	})
 }
 
 // DelRoleAccess 删除角色权限
@@ -178,19 +219,26 @@ func (r *Role) UpdateRoleAccess(ctx *gin.Context) {
 // @Success 200 {object} entity.Response
 // @Router /v1/admin/role/role_access/del [get]
 func (r *Role) DelRoleAccess(ctx *gin.Context) {
-	var req entity.RoleAccessDelReq
+	req := new(entity.RoleAccessDelReq)
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	err := r.sev.DelRoleAccess(ctx, req)
+	err := new(service.Role).DelRoleAccess(ctx, *req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, nil)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+	})
 }
 
 // GetRoleAccessList 获取角色权限列表根据角色ID
@@ -203,19 +251,27 @@ func (r *Role) DelRoleAccess(ctx *gin.Context) {
 // @Success 200 {object} []entity.AccessResp
 // @Router /v1/admin/role/role_access/list [get]
 func (r *Role) GetRoleAccessList(ctx *gin.Context) {
-	var req entity.RoleAccessListReq
+	req := new(entity.RoleAccessListReq)
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	resp, err := r.sev.GetRoleAccessList(ctx, req)
+	list, err := new(service.Role).GetRoleAccessList(ctx, *req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, resp)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+		"data": list,
+	})
 }
 
 // AddAccess 添加权限路由
@@ -228,19 +284,26 @@ func (r *Role) GetRoleAccessList(ctx *gin.Context) {
 // @Success 200 {object} entity.Response
 // @Router /v1/admin/role/access/add [post]
 func (r *Role) AddAccess(ctx *gin.Context) {
-	var req entity.AccessAddReq
+	req := new(entity.AccessAddReq)
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	err := r.sev.AddAccess(ctx, req)
+	err := new(service.Role).AddAccess(ctx, *req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, nil)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+	})
 }
 
 // DelAccess
@@ -253,19 +316,27 @@ func (r *Role) AddAccess(ctx *gin.Context) {
 // @Success 200 {object} entity.Response
 // @Router /v1/admin/role/access/del [Get]
 func (r *Role) DelAccess(ctx *gin.Context) {
-	var req entity.AccessDelReq
+	req := new(entity.AccessDelReq)
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	err := r.sev.DelAccess(ctx, req)
+	err := new(service.Role).DelAccess(ctx, *req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+	})
 
-	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // UpdateAccess  修改权限路由
@@ -278,19 +349,26 @@ func (r *Role) DelAccess(ctx *gin.Context) {
 // @Success 200 {object} entity.Response
 // @Router /v1/admin/role/access/update [post]
 func (r *Role) UpdateAccess(ctx *gin.Context) {
-	var req entity.AccessUpdateReq
+	req := new(entity.AccessUpdateReq)
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	err := r.sev.UpdateAccess(ctx, req)
+	err := new(service.Role).UpdateAccess(ctx, *req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, nil)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+	})
 }
 
 // ListAccess 获取权限路由列表
@@ -303,19 +381,28 @@ func (r *Role) UpdateAccess(ctx *gin.Context) {
 // @Success 200 {object} []entity.AccessResp
 // @Router /v1/admin/role/access/list [get]
 func (r *Role) ListAccess(ctx *gin.Context) {
-	var req entity.AccessListReq
+	req := new(entity.AccessListReq)
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	resp, err := r.sev.ListAccess(ctx, req)
+	list, err := new(service.Role).ListAccess(ctx, req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, resp)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code":  200,
+		"msg":   "success",
+		"data":  list,
+		"total": req.Count,
+	})
 }
 
 // GetAdminRole
@@ -328,19 +415,28 @@ func (r *Role) ListAccess(ctx *gin.Context) {
 // @Success 200 {object} entity.AdminBindRoleResp
 // @Router /v1/admin/role/admin_role_info [post]
 func (r *Role) GetAdminRole(ctx *gin.Context) {
-	var req entity.AdminBindRoleReq
+	req := new(entity.AdminBindRoleReq)
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	resp, err := r.sev.GetAdminRole(ctx, req)
+	list, err := new(service.Role).GetAdminRole(ctx, req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, resp)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+		"data": list,
+	})
+	return
 }
 
 // AdminBindRole 绑定角色
@@ -353,19 +449,27 @@ func (r *Role) GetAdminRole(ctx *gin.Context) {
 // @Success 200 {object} entity.Response
 // @Router /v1/admin/role/admin_bind_role [post]
 func (r *Role) AdminBindRole(ctx *gin.Context) {
-	var req entity.AdminBindRoleReq
+	req := new(entity.AdminBindRoleReq)
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	err := r.sev.AdminBindRole(ctx, req)
+	err := new(service.Role).AdminBindRole(ctx, req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+	})
 
-	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // AdminUnBindRole 取消绑定角色
@@ -378,17 +482,24 @@ func (r *Role) AdminBindRole(ctx *gin.Context) {
 // @Success 200 {object} entity.Response
 // @Router /v1/admin/role/admin_unbind_role [post]
 func (r *Role) AdminUnBindRole(ctx *gin.Context) {
-	var req entity.AdminBindRoleReq
+	req := new(entity.AdminBindRoleReq)
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	err := r.sev.AdminUnBindRole(ctx, req)
+	err := new(service.Role).AdminUnBindRole(ctx, req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, nil)
+	ctx.JSON(http.StatusOK, gin.H{
+		"code": 200,
+		"msg":  "success",
+	})
 }

game/game_cluster/nodes/webadmin/controller/synthesis.go

@@ -2,8 +2,6 @@ package controller
 
 import (
 	"github.com/gin-gonic/gin"
-	"github.com/mhaya/game/game_cluster/internal/code"
-	"github.com/mhaya/game/game_cluster/nodes/webadmin/common"
 	"github.com/mhaya/game/game_cluster/nodes/webadmin/entity"
 	"github.com/mhaya/game/game_cluster/nodes/webadmin/service"
 )
@@ -20,107 +18,168 @@ func NewSynthesis() *Synthesis {
 
 // FindUserLogDaily 查询用户日活跃
 func (s *Synthesis) FindUserLogDaily(ctx *gin.Context) {
-	var req entity.UserLogDailyReq
+	req := &entity.UserLogDailyReq{}
 	if err := ctx.ShouldBindJSON(req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
 	resp, err := s.sev.FindMDBUserLogDaily(req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, resp)
+	ctx.JSON(200, gin.H{
+		"code":  200,
+		"msg":   "success",
+		"data":  resp,
+		"total": req.Total,
+	})
 }
 
 // FindUserRetention 查询用户留存
 func (s *Synthesis) FindUserRetention(ctx *gin.Context) {
-	var req entity.UserRetentionReq
+	req := &entity.UserRetentionReq{}
 	if err := ctx.ShouldBindJSON(req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
 	resp, err := s.sev.FindUserRetention(req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
+	} else {
+		ctx.JSON(200, gin.H{
+			"code":  200,
+			"msg":   "success",
+			"data":  resp,
+			"total": req.Total,
+		})
 	}
 
-	common.PackOkResult(ctx, code.OK, resp)
 }
 
 // FindUserCountryCount 查询用户国家分布
 func (s *Synthesis) FindUserCountryCount(ctx *gin.Context) {
 	resp, err := s.sev.FindUserCountryCount()
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
+	} else {
+		ctx.JSON(200, gin.H{
+			"code": 200,
+			"msg":  "success",
+			"data": resp,
+		})
 	}
-
-	common.PackOkResult(ctx, code.OK, resp)
 }
 
 // FindWithdrawal 查询提现记录
 func (s *Synthesis) FindWithdrawal(ctx *gin.Context) {
-	var req entity.UserWithdrawalReq
+	req := &entity.UserWithdrawalReq{}
 	if err := ctx.ShouldBindJSON(req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	resp, err := s.sev.FindWithdrawal(req)
+	var total int64
+	resp, total, err := s.sev.FindWithdrawal(req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
+	} else {
+		ctx.JSON(200, gin.H{
+			"code":  200,
+			"msg":   "success",
+			"data":  resp,
+			"total": total,
+		})
 	}
-
-	common.PackOkResult(ctx, code.OK, resp)
 }
 
 // WithdrawalStatus 修改提现状态
 func (s *Synthesis) WithdrawalStatus(ctx *gin.Context) {
-	var req entity.UserWithdrawalStatus
+	req := &entity.UserWithdrawalStatus{}
 	if err := ctx.ShouldBindJSON(req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
 	err := s.sev.WithdrawalStatus(req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
+	} else {
+		ctx.JSON(200, gin.H{
+			"code": 200,
+			"msg":  "success",
+		})
 	}
-
-	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // WithdrawalStatusBatch 修改提现状态批量
 func (s *Synthesis) WithdrawalStatusBatch(ctx *gin.Context) {
-	var req entity.UserWithdrawalStatusBatch
+	req := &entity.UserWithdrawalStatusBatch{}
 	if err := ctx.ShouldBindJSON(req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
 	err := s.sev.WithdrawalStatusBatch(req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
+	} else {
+		ctx.JSON(200, gin.H{
+			"code": 200,
+			"msg":  "success",
+		})
 	}
-
-	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // FindUserLevel 查询用户等级
 func (s *Synthesis) FindUserLevel(ctx *gin.Context) {
 	resp, err := s.sev.FindUserLevel()
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
+	} else {
+		ctx.JSON(200, gin.H{
+			"code": 200,
+			"msg":  "success",
+			"data": resp,
+		})
 	}
-
-	common.PackOkResult(ctx, code.OK, resp)
 }

game/game_cluster/nodes/webadmin/controller/whitelist.go

@@ -2,20 +2,15 @@ package controller
 
 import (
 	"github.com/gin-gonic/gin"
-	"github.com/mhaya/game/game_cluster/internal/code"
-	"github.com/mhaya/game/game_cluster/nodes/webadmin/common"
 	"github.com/mhaya/game/game_cluster/nodes/webadmin/entity"
 	"github.com/mhaya/game/game_cluster/nodes/webadmin/service"
 )
 
 type Whitelist struct {
-	sev *service.Whitelist
 }
 
 func NewWhitelist() *Whitelist {
-	return &Whitelist{
-		sev: service.NewWhitelist(),
-	}
+	return &Whitelist{}
 }
 
 // GetWhitelist 获取白名单
@@ -28,19 +23,28 @@ func NewWhitelist() *Whitelist {
 // @Success 200 {object} []models.Whitelist "返回结果"
 // @Router /v1/admin/whitelist/list [post]
 func (w *Whitelist) GetWhitelist(ctx *gin.Context) {
-	var req entity.WhitelistListReq
+	req := &entity.WhitelistListReq{}
 	if err := ctx.ShouldBindJSON(req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	resp, err := w.sev.GetAll(req)
+	whitelists, err := new(service.Whitelist).GetAll(req)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, resp)
+	ctx.JSON(200, gin.H{
+		"code":  200,
+		"data":  whitelists,
+		"msg":   "success",
+		"total": req.Count,
+	})
 }
 
 // AddWhitelist 新增白名单
@@ -53,19 +57,25 @@ func (w *Whitelist) GetWhitelist(ctx *gin.Context) {
 // @Success 200 {object} entity.Response "返回结果"
 // @Router /v1/admin/whitelist/add [post]
 func (w *Whitelist) AddWhitelist(ctx *gin.Context) {
-	var req entity.WhitelistAddReq
+	req := &entity.WhitelistAddReq{}
 	if err := ctx.ShouldBindJSON(req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	err := w.sev.Add(req)
+	err := new(service.Whitelist).Add(req.IP, req.Desc)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, nil)
+	ctx.JSON(200, gin.H{
+		"code": 200,
+	})
 }
 
 // RemoveWhitelist 删除白名单
@@ -78,17 +88,23 @@ func (w *Whitelist) AddWhitelist(ctx *gin.Context) {
 // @Success 200 {object} entity.Response "返回结果"
 // @Router /v1/admin/whitelist/remove [post]
 func (w *Whitelist) RemoveWhitelist(ctx *gin.Context) {
-	var req entity.WhitelistRemoveReq
+	req := &entity.WhitelistRemoveReq{}
 	if err := ctx.ShouldBindJSON(req); err != nil {
-		common.PackOkResult(ctx, code.ParamError)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	err := w.sev.Remove(req)
+	err := new(service.Whitelist).Remove(req.IP)
 	if err != nil {
-		common.PackOkResult(ctx, err.Code)
+		ctx.JSON(200, gin.H{
+			"code": 400,
+			"msg":  err.Error(),
+		})
 		return
 	}
-
-	common.PackOkResult(ctx, code.OK, nil)
+	ctx.JSON(200, gin.H{
+		"code": 200,
+	})
 }

game/game_cluster/nodes/webadmin/entity/admin.go

@@ -19,11 +19,6 @@ type AdminAddReq struct {
 }
 
 type AdminListResp struct {
-	Details []*AdminListDetail `json:"details"`
-	Total   int64              `json:"total"`
-}
-
-type AdminListDetail struct {
 	Id            interface{} `json:"id" bson:"_id"`                          // 自增ID
 	Username      string      `json:"username" bson:"username"`               // 用户名
 	Password      string      `json:"password" bson:"password"`               // 密码

game/game_cluster/nodes/webadmin/entity/role.go

@@ -1,11 +1,6 @@
 package entity
 
 type RoleResp struct {
-	Details []*RoleDetail `json:"details"`
-	Total   int64         `json:"total"`
-}
-
-type RoleDetail struct {
 	Id        string `gorm:"column:id;primaryKey" json:"id" bson:"_id"`
 	RenterId  uint64 `gorm:"column:renter_id;type:bigint;NOT NULL;comment:租户ID;" json:"renter_id" bson:"renter_id"`
 	Name      string `gorm:"column:name;type:varchar(1024);NOT NULL;comment:角色名称" json:"name" bson:"name"`
@@ -17,22 +12,17 @@ type RoleDetail struct {
 }
 
 type AccessResp struct {
-	Details []*AccessDetail `json:"details"`
-	Total   int64           `json:"total"`
-}
-
-type AccessDetail struct {
-	ID          string          `bson:"id" json:"id,omitempty"`
-	ModuleName  string          `bson:"module_name" json:"module_name,omitempty"` // 模块名称
-	ActionName  string          `bson:"action_name" json:"action_name,omitempty"` // 操作名称
-	ParentId    string          `bson:"parent_id" json:"parent_id,omitempty"`     // 父级ID
-	Type        int             `bson:"type" json:"type,omitempty"`               // 节点类型 :  1、表示模块    2、表示菜单     3、操作
-	URL         string          `bson:"url" json:"url,omitempty"`                 // 路由跳转地址
-	Sort        int             `bson:"sort" json:"sort,omitempty"`               // 排序
-	Description string          `bson:"description" json:"description,omitempty"` // 描述
-	Status      int             `bson:"status" json:"status,omitempty"`           // 状态 1、正常  2、禁用
-	AddTime     int             `bson:"add_time" json:"add_time,omitempty"`       // 添加时间-
-	AccessItem  []*AccessDetail `bson:"access_item" json:"access_item"`           // 子节点
+	ID          string        `bson:"id" json:"id,omitempty"`
+	ModuleName  string        `bson:"module_name" json:"module_name,omitempty"` // 模块名称
+	ActionName  string        `bson:"action_name" json:"action_name,omitempty"` // 操作名称
+	ParentId    string        `bson:"parent_id" json:"parent_id,omitempty"`     // 父级ID
+	Type        int           `bson:"type" json:"type,omitempty"`               // 节点类型 :  1、表示模块    2、表示菜单     3、操作
+	URL         string        `bson:"url" json:"url,omitempty"`                 // 路由跳转地址
+	Sort        int           `bson:"sort" json:"sort,omitempty"`               // 排序
+	Description string        `bson:"description" json:"description,omitempty"` // 描述
+	Status      int           `bson:"status" json:"status,omitempty"`           // 状态 1、正常  2、禁用
+	AddTime     int           `bson:"add_time" json:"add_time,omitempty"`       // 添加时间-
+	AccessItem  []*AccessResp `bson:"access_item" json:"access_item"`           // 子节点
 }
 
 type RoleListReq struct {
@@ -135,9 +125,9 @@ type AdminRoleByIDReq struct {
 }
 
 type AdminBindRoleResp struct {
-	RoleId     string          `json:"role_id"`    // 角色ID
-	AdminId    string          `json:"admin_id"`   // 管理员ID
-	AdminName  string          `json:"admin_name"` // 管理员名称
-	RoleName   string          `json:"role_name"`  // 角色名称
-	AccessList []*AccessDetail `json:"access_list"`
+	RoleId     string        `json:"role_id"`    // 角色ID
+	AdminId    string        `json:"admin_id"`   // 管理员ID
+	AdminName  string        `json:"admin_name"` // 管理员名称
+	RoleName   string        `json:"role_name"`  // 角色名称
+	AccessList []*AccessResp `json:"access_list"`
 }

game/game_cluster/nodes/webadmin/entity/user_country_count.go

@@ -1,11 +1,6 @@
 package entity
 
 type UserCountryResp struct {
-	Details []*UserCountryDetail `json:"details"`
-	Total   int64                `json:"total"`
-}
-
-type UserCountryDetail struct {
 	Country    string  `json:"country"`    // 国家
 	IPCount    int     `json:"ip_count"`   // IP数量
 	Percentage float64 `json:"percentage"` // 百分比

game/game_cluster/nodes/webadmin/entity/user_lavel_count.go

@@ -1,11 +1,6 @@
 package entity
 
 type UserLevelCountResp struct {
-	Details []*UserLevelCountDetail `json:"details"`
-	Total   int64                   `json:"total"`
-}
-
-type UserLevelCountDetail struct {
 	Level     int `json:"level" bson:"level"`
 	UserCount int `json:"user_count" bson:"user_count"`
 }

game/game_cluster/nodes/webadmin/entity/user_log_daily.go

@@ -1,11 +1,6 @@
 package entity
 
 type UserLogDailyResp struct {
-	Details []*UserLogDailyDetail `json:"details"`
-	Total   int64                 `json:"total"`
-}
-
-type UserLogDailyDetail struct {
 	Platform    string  `bson:"platform"  json:"platform"`        // platform: 用户所在的平台，例如“Android”或“IOS”
 	Channel     string  `bson:"channel" json:"channel"`           // channel: 用户来源渠道
 	Registered  int     `bson:"registered" json:"registered"`     // registered: 新用户注册的数量

game/game_cluster/nodes/webadmin/entity/user_reg_count.go

@@ -2,11 +2,6 @@ package entity
 
 // UserRetentionResp 用于存储用户的留存数据
 type UserRetentionResp struct {
-	Details []*UserRetentionDetail `json:"details"`
-	Total   int64                  `json:"total"`
-}
-
-type UserRetentionDetail struct {
 	ID               string    `bson:"_id"`               // 用户唯一标识符
 	RegistrationDate int64     `bson:"registration_date"` // 注册日期
 	RetentionData    Retention `bson:"retention_data"`

game/game_cluster/nodes/webadmin/entity/user_withdrawal.go

@@ -1,12 +1,7 @@
 package entity
 
-type UserWithdrawalResp struct {
-	Details []*UserWithdrawalDetail `json:"details"`
-	Total   int64                   `json:"total"`
-}
-
 // UserWithdrawalResp \game\game_cluster\nodes\webadmin\entity\user_withdrawal.go
-type UserWithdrawalDetail struct {
+type UserWithdrawalResp struct {
 	Id          string      `json:"id" bson:"_id"`                    // Id
 	UserName    string      `json:"user_name" bson:"userName"`        // 用户ID
 	NickName    string      `json:"nick_name" bson:"nickName"`        // 昵称

game/game_cluster/nodes/webadmin/entity/whitelist.go

@@ -1,7 +1,5 @@
 package entity
 
-import "github.com/mhaya/game/game_cluster/internal/mdb/models"
-
 type WhitelistListReq struct {
 	Page  int    `json:"page" binding:"required"`
 	Size  int    `json:"size" binding:"required"`
@@ -9,11 +7,6 @@ type WhitelistListReq struct {
 	IP    string `json:"ip"`
 }
 
-type WhitelistListResp struct {
-	Details []models.Whitelist `json:"details"`
-	Total   int64              `json:"total"`
-}
-
 type WhitelistAddReq struct {
 	IP   string `json:"ip" binding:"required"`
 	Desc string `json:"desc"`

game/game_cluster/nodes/webadmin/service/admin.go

@@ -3,19 +3,18 @@ package service
 import (
 	"context"
 	"errors"
+	"fmt"
+	"log"
 	"regexp"
 	"strings"
 	"time"
 
 	"github.com/gin-gonic/gin"
-	"github.com/mhaya/game/game_cluster/internal/code"
 	"github.com/mhaya/game/game_cluster/internal/constant"
 	"github.com/mhaya/game/game_cluster/internal/mdb"
 	"github.com/mhaya/game/game_cluster/internal/mdb/models"
-	"github.com/mhaya/game/game_cluster/nodes/webadmin/common"
 	"github.com/mhaya/game/game_cluster/nodes/webadmin/entity"
 	"github.com/mhaya/game/game_cluster/nodes/webadmin/model"
-	mhayaLogger "github.com/mhaya/logger"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
@@ -40,7 +39,6 @@ func (a *Admin) GetDB() *mongo.Database {
 func (a *Admin) GetDBName() string {
 	return "admin"
 }
-
 func CheckPasswordHash(password, hash string) bool {
 	err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
 	return err == nil
@@ -53,65 +51,52 @@ func HashPassword(password string) (string, error) {
 }
 
 // Login 登录
-func (a *Admin) Login(ctx *gin.Context, username string, password string) (*entity.AdminResp, *code.Result) {
+func (a *Admin) Login(ctx *gin.Context, username string, password string) (*entity.AdminResp, error) {
 	user, err := a.QueryUserByUsername(ctx, username)
 	if err != nil {
-		mhayaLogger.Warnf("Login QueryUserByUsername error:", err)
-		return nil, common.NewResult(code.InternalError)
+		log.Printf("Failed to query user: %s", err)
+		return nil, fmt.Errorf("failed to query user: %s", err)
 	}
-
 	// 判断用户状态
 	if user.Status != 1 {
-		return nil, common.NewResult(code.DisabledUserError)
+		log.Println("User is disabled")
+		return nil, errors.New("user is disabled")
 	}
-
 	// 判断密码
 	if !CheckPasswordHash(password, user.Password) {
-		return nil, common.NewResult(code.UserNameOrPasswordError)
+		log.Println("Invalid username or password")
+		return nil, errors.New("invalid username or password")
 	}
-
 	// 创建token
 	generateToken, err := user.GenerateToken()
 	if err != nil {
-		mhayaLogger.Warnf("Login GenerateToken error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
-
 	// 保存token 到 redis 中 过期时间为1天
 	err = mdb.RDB.Set(ctx, generateToken, user.Username, 24*time.Hour).Err()
 	if err != nil {
-		mhayaLogger.Warnf("Login Set error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
-
 	err = a.loginAuthSetRoleRedis(user.RoleId, generateToken)
 	if err != nil {
-		mhayaLogger.Warnf("Login loginAuthSetRoleRedis error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
-
 	// 更新用户登录时间
 	_, err = mdb.MDB.Collection(a.GetDBName()).UpdateOne(ctx, bson.M{"username": username}, bson.M{"$set": bson.M{"last_login_time": time.Now().Unix()}})
+	log.Printf("Login successful for user: %s", username)
 	if err != nil {
-		mhayaLogger.Warnf("Login UpdateOne last_login_time error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
-
 	// 更新用户IP
 	ip := ctx.ClientIP()
 	_, err = mdb.MDB.Collection(a.GetDBName()).UpdateOne(ctx, bson.M{"username": username}, bson.M{"$set": bson.M{"last_login_ip": ip}})
-	if err != nil {
-		mhayaLogger.Warnf("Login UpdateOne ip error:", err)
-		return nil, common.NewResult(code.InternalError)
-	}
 
 	// 返回用户信息
-	resp := &entity.AdminResp{
+	log.Printf("Returning user: %s", username)
+	return &entity.AdminResp{
 		ToKen:  generateToken,
 		RoleID: user.RoleId,
-	}
-	mhayaLogger.Debugf("Login result:", resp)
-	return resp, nil
+	}, nil
 }
 
 // LoginAuthSetRoleRedis 登录时写入该用户的权限
@@ -119,6 +104,7 @@ func (a *Admin) loginAuthSetRoleRedis(roleID, generateToken string) error {
 	if roleID == constant.AdminAccess {
 		mdb.RDB.HSet(context.Background(), "admin::token::"+generateToken, constant.AdminAccess, 1)
 		mdb.RDB.Expire(context.Background(), "admin::token::"+generateToken, 24*time.Hour).Err()
+
 		return nil
 	}
 
@@ -131,7 +117,6 @@ func (a *Admin) loginAuthSetRoleRedis(roleID, generateToken string) error {
 	if err != nil {
 		return err
 	}
-
 	roleAccess := models.RoleAccess{}
 	collection = mdb.MDB.Collection(roleAccess.TableName())
 	roleAccessFilter := bson.M{"role_id": roleID}
@@ -139,7 +124,6 @@ func (a *Admin) loginAuthSetRoleRedis(roleID, generateToken string) error {
 	if err != nil {
 		return err
 	}
-
 	// 写入redis
 	var accessIDS []primitive.ObjectID
 	for _, v := range roleAccess.AccessID {
@@ -155,16 +139,13 @@ func (a *Admin) loginAuthSetRoleRedis(roleID, generateToken string) error {
 	if err != nil {
 		return err
 	}
-
 	if err = cursor.All(context.Background(), &accessList); err != nil {
 		return err
 	}
-
 	for _, v := range accessList {
 		mdb.RDB.HSet(context.Background(), "admin::token::"+generateToken, v.URL, 1)
 	}
 	mdb.RDB.Expire(context.Background(), "admin::token::"+generateToken, 24*time.Hour).Err()
-
 	return nil
 
 }
@@ -215,20 +196,18 @@ func (a *Admin) QueryUserByUsername(ctx context.Context, username string) (*mode
 }
 
 // ChangePassword 修改管理员密码
-func (a *Admin) ChangePassword(ctx context.Context, username string, password string) *code.Result {
+func (a *Admin) ChangePassword(ctx context.Context, username string, password string) error {
 	// 更新密码
 	password, _ = HashPassword(password)
 	_, err := mdb.MDB.Collection(a.GetDBName()).UpdateOne(ctx, bson.M{"username": username}, bson.M{"$set": bson.M{"password": password}})
 	if err != nil {
-		mhayaLogger.Warnf("ChangePassword UpdateOne error:", err)
-		return common.NewResult(code.InternalError)
+		return err
 	}
-
 	return nil
 }
 
 // Add 添加管理员
-func (a *Admin) Add(ctx context.Context, username string, password string, realName string, pid string, roleId string, status int) *code.Result {
+func (a *Admin) Add(ctx context.Context, username string, password string, realName string, pid string, roleId string, status int) error {
 	// 判断账号是否重复
 	admin := model.Admin{}
 	err := mdb.MDB.Collection(a.GetDBName()).FindOne(ctx, bson.M{"username": username}).Decode(&admin)
@@ -245,42 +224,36 @@ func (a *Admin) Add(ctx context.Context, username string, password string, realN
 			"updated_at": time.Now().Unix(),
 		})
 		if err != nil {
-			mhayaLogger.Warnf("Add InsertOne error:", err)
-			return common.NewResult(code.InternalError)
+			return err
 		}
-
 		return nil
 	}
-
-	return common.NewResult(code.AccountExistError)
+	return fmt.Errorf("账号已存在")
 }
 
 // Delete 删除管理员
-func (a *Admin) Delete(ctx context.Context, username string) *code.Result {
+func (a *Admin) Delete(ctx context.Context, username string) error {
 	_, err := mdb.MDB.Collection(a.GetDBName()).DeleteOne(ctx, bson.M{"username": username})
 	if err != nil {
-		mhayaLogger.Warnf("Delete DeleteOne error:", err)
-		return common.NewResult(code.InternalError)
+		return err
 	}
-
 	return nil
 }
 
 // UpdateStatus updateStatus
-func (a *Admin) UpdateStatus(ctx context.Context, username string, status int) *code.Result {
+func (a *Admin) UpdateStatus(ctx context.Context, username string, status int) error {
 	_, err := mdb.MDB.Collection(a.GetDBName()).UpdateOne(ctx, bson.M{"username": username}, bson.M{"$set": bson.M{"status": status}})
 	if err != nil {
-		mhayaLogger.Warnf("Delete UpdateOne error:", err)
-		return common.NewResult(code.InternalError)
+		return err
 	}
-
 	return nil
+
 }
 
 // FindAll 查找所有管理员信息
-func (a *Admin) FindAll(ctx context.Context, page int, pageSize int, username string) (*entity.AdminListResp, *code.Result) {
+func (a *Admin) FindAll(ctx context.Context, page int, pageSize int, username string) ([]*entity.AdminListResp, int64, error) {
 	// 日志记录
-	mhayaLogger.Warnf("Finding admins with page %d and page size %d, username: %s", page, pageSize, maskUsername(username))
+	log.Printf("Finding admins with page %d and page size %d, username: %s", page, pageSize, maskUsername(username))
 
 	// 验证参数
 	if page <= 0 {
@@ -298,8 +271,7 @@ func (a *Admin) FindAll(ctx context.Context, page int, pageSize int, username st
 	// 查询总数
 	count, err := mdb.MDB.Collection("admin").CountDocuments(ctx, filter)
 	if err != nil {
-		mhayaLogger.Warnf("FindAll CountDocuments error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, 0, err
 	}
 
 	// 设置分页选项
@@ -310,12 +282,11 @@ func (a *Admin) FindAll(ctx context.Context, page int, pageSize int, username st
 	// 执行查询
 	cursor, err := mdb.MDB.Collection("admin").Find(ctx, filter, findOptions)
 	if err != nil {
-		mhayaLogger.Warnf("FindAll Find error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, 0, err
 	}
 	defer func() {
 		if closeErr := cursor.Close(ctx); closeErr != nil {
-			mhayaLogger.Warnf("Error closing cursor: %v", closeErr)
+			log.Printf("Error closing cursor: %v", closeErr)
 		}
 	}()
 
@@ -325,23 +296,21 @@ func (a *Admin) FindAll(ctx context.Context, page int, pageSize int, username st
 		var admin model.Admin
 		err := cursor.Decode(&admin)
 		if err != nil {
-			mhayaLogger.Warnf("FindAll Decode error:", err)
-			return nil, common.NewResult(code.InternalError)
+			return nil, 0, err
 		}
 		admins = append(admins, &admin)
 	}
 
 	if err := cursor.Err(); err != nil {
-		mhayaLogger.Warnf("FindAll cursor error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, 0, err
 	}
 
-	var details []*entity.AdminListDetail
+	var data []*entity.AdminListResp
 	for _, admin := range admins {
 		roleName := ""
 		roleName, _ = a.GetRoleName(admin.RoleId)
 
-		details = append(details, &entity.AdminListDetail{
+		data = append(data, &entity.AdminListResp{
 			Id:            admin.GetID(),
 			Username:      admin.Username,
 			RealName:      admin.RealName,
@@ -355,10 +324,7 @@ func (a *Admin) FindAll(ctx context.Context, page int, pageSize int, username st
 		})
 	}
 
-	return &entity.AdminListResp{
-		Details: details,
-		Total:   count,
-	}, nil
+	return data, count, nil
 }
 
 func (a *Admin) GetRoleName(roleID string) (string, error) {
@@ -372,37 +338,31 @@ func (a *Admin) GetRoleName(roleID string) (string, error) {
 }
 
 // GetServerStatus 获取服务器状态
-func (a *Admin) GetServerStatus(ctx context.Context) ([]*models.PlayerServerLoadStat, *code.Result) {
+func (a *Admin) GetServerStatus(ctx context.Context) ([]*models.PlayerServerLoadStat, error) {
 	// 执行查询
 	cursor, err := mdb.MDB.Collection(constant.CNameServerLoadStat).Find(ctx, bson.M{})
 	if err != nil {
-		mhayaLogger.Warnf("GetServerStatus Find error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
-
 	defer func() {
 		if closeErr := cursor.Close(ctx); closeErr != nil {
-			mhayaLogger.Warnf("Error closing cursor: %v", closeErr)
+			log.Printf("Error closing cursor: %v", closeErr)
 		}
 	}()
-
 	// 解析结果
 	admins := make([]*models.PlayerServerLoadStat, 0)
 	for cursor.Next(ctx) {
 		var admin models.PlayerServerLoadStat
 		err := cursor.Decode(&admin)
 		if err != nil {
-			mhayaLogger.Warnf("GetServerStatus Decode error:", err)
-			return nil, common.NewResult(code.InternalError)
+			return nil, err
 		}
 		admins = append(admins, &admin)
 	}
 
 	if err := cursor.Err(); err != nil {
-		mhayaLogger.Warnf("GetServerStatus cursor error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
-
 	return admins, nil
 }
 
@@ -411,7 +371,6 @@ func maskUsername(username string) string {
 	if username == "" {
 		return ""
 	}
-
 	return strings.Repeat("*", len(username))
 }
 

game/game_cluster/nodes/webadmin/service/role.go

@@ -4,17 +4,15 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log"
 	"strings"
 	"sync"
 	"time"
 
-	"github.com/mhaya/game/game_cluster/internal/code"
 	"github.com/mhaya/game/game_cluster/internal/mdb"
 	"github.com/mhaya/game/game_cluster/internal/mdb/models"
-	"github.com/mhaya/game/game_cluster/nodes/webadmin/common"
 	"github.com/mhaya/game/game_cluster/nodes/webadmin/entity"
 	"github.com/mhaya/game/game_cluster/nodes/webadmin/model"
-	mhayaLogger "github.com/mhaya/logger"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
@@ -29,7 +27,7 @@ func NewRole() *Role {
 }
 
 // List 角色列表
-func (r *Role) List(ctx context.Context, req entity.RoleListReq) (*entity.RoleResp, *code.Result) {
+func (r *Role) List(ctx context.Context, req *entity.RoleListReq) ([]entity.RoleResp, error) {
 	roles := models.Roles{}
 	rolesCollection := mdb.MDB.Collection(roles.TableName())
 	// 构建过滤器
@@ -42,69 +40,60 @@ func (r *Role) List(ctx context.Context, req entity.RoleListReq) (*entity.RoleRe
 	}
 	// 数据验证
 	if req.Page <= 0 || req.Size <= 0 {
-		mhayaLogger.Warnf("List param error, req.Page:%d, req.Size:%d", req.Page, req.Size)
-		return nil, common.NewResult(code.ParamError)
+		return nil, fmt.Errorf("invalid page or size")
 	}
 	// 设置分页选项
 	findOptions := options.Find().SetSkip(int64((req.Page - 1) * req.Size)).SetLimit(int64(req.Size))
 	countDocuments, err := rolesCollection.CountDocuments(ctx, filter)
 	if err != nil {
-		mhayaLogger.Warnf("List CountDocuments error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
-
+	req.Count = countDocuments
 	// 防御性编程
 	tableName := roles.TableName()
 	if tableName == "" {
-		mhayaLogger.Warnf("List tableName is nil, tableName:", tableName)
-		return nil, common.NewResult(code.InternalError)
+		return nil, fmt.Errorf("invalid table name")
 	}
 
 	cursor, err := rolesCollection.Find(ctx, filter, findOptions)
 	if err != nil {
-		mhayaLogger.Warnf("List Find error:", err)
-		return nil, common.NewResult(code.InternalError)
+		log.Printf("Failed to execute query: %v", err)
+		return nil, err
 	}
 	defer func() {
 		if err := cursor.Close(ctx); err != nil {
-			mhayaLogger.Warnf("Failed to close cursor: %v", err)
+			log.Printf("Failed to close cursor: %v", err)
 		}
 	}()
 
-	var details []*entity.RoleDetail
+	var result []entity.RoleResp
 	for cursor.Next(ctx) {
-		var role *entity.RoleDetail
+		var role entity.RoleResp
 		if err := cursor.Decode(&role); err != nil {
-			mhayaLogger.Warnf("List Decode error:", err)
-			return nil, common.NewResult(code.InternalError)
+			log.Printf("Failed to decode document: %v", err)
+			return nil, err
 		}
-		details = append(details, role)
+		result = append(result, role)
 	}
 
 	if err := cursor.Err(); err != nil {
-		mhayaLogger.Warnf("List cursor error:", err)
-		return nil, common.NewResult(code.InternalError)
+		log.Printf("Cursor error: %v", err)
+		return nil, err
 	}
 
-	return &entity.RoleResp{
-		Details: details,
-		Total:   countDocuments,
-	}, nil
+	return result, nil
 }
 
 // Add 新增角色
-func (r *Role) Add(ctx context.Context, req entity.RoleAddReq) *code.Result {
+func (r *Role) Add(ctx context.Context, req entity.RoleAddReq) error {
 	// 验证角色名称是否已存在
-	if !r.checkRoleNameExist(req.Name) {
-		return common.NewResult(code.RoleNameExistError)
+	if r.checkRoleNameExist(req.Name) == false {
+		return fmt.Errorf("角色名称已存在")
 	}
-
 	// 检查上下文是否有效
 	if ctx.Err() != nil {
-		mhayaLogger.Warnf("Add ctx error:", ctx.Err())
-		return common.NewResult(code.InternalError)
+		return ctx.Err()
 	}
-
 	// 插入新角色记录
 	roles := models.Roles{}
 	insertData := bson.M{}
@@ -116,22 +105,19 @@ func (r *Role) Add(ctx context.Context, req entity.RoleAddReq) *code.Result {
 	collection := mdb.MDB.Collection(roles.TableName())
 	_, insertErr := collection.InsertOne(ctx, req)
 	if insertErr != nil {
-		mhayaLogger.Warnf("Add InsertOne error:", insertErr)
-		return common.NewResult(code.InternalError)
+		log.Printf("Failed to insert role: %s", insertErr)
+		return insertErr
 	}
-
 	return nil
 }
 
 // Update 修改角色
-func (r *Role) Update(ctx context.Context, req entity.RoleUpdateReq) *code.Result {
+func (r *Role) Update(ctx context.Context, req entity.RoleUpdateReq) error {
 	// 更新条件
 	objID, err := primitive.ObjectIDFromHex(req.Id)
 	if err != nil {
-		mhayaLogger.Warnf("Update req.Id error:", req.Id)
-		return common.NewResult(code.ParamError)
+		return fmt.Errorf("invalid ObjectID: %v", err)
 	}
-
 	updateCondition := bson.M{"_id": objID}
 	// 更新内容
 	updateContent := bson.M{
@@ -148,10 +134,8 @@ func (r *Role) Update(ctx context.Context, req entity.RoleUpdateReq) *code.Resul
 	// 执行更新操作
 	_, err = collection.UpdateOne(context.TODO(), updateCondition, updateContent, updateOptions)
 	if err != nil {
-		mhayaLogger.Warnf("Update UpdateOne error:", err)
-		return common.NewResult(code.InternalError)
+		return err
 	}
-
 	return nil
 }
 
@@ -169,7 +153,7 @@ func (r *Role) checkRoleNameExist(name string) bool {
 	// 执行查询
 	if err := collection.FindOne(ctx, filter).Err(); err != nil {
 		if errors.Is(err, mongo.ErrNoDocuments) {
-			mhayaLogger.Warnf("No document found with role name: %s", name)
+			log.Printf("No document found with role name: %s", name)
 			return true
 		}
 		return false
@@ -178,7 +162,7 @@ func (r *Role) checkRoleNameExist(name string) bool {
 }
 
 // Del 删除角色
-func (r *Role) Del(ctx context.Context, req entity.RoleDelReq) *code.Result {
+func (r *Role) Del(ctx context.Context, req entity.RoleDelReq) error {
 	// 创建带超时的上下文
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
@@ -186,29 +170,22 @@ func (r *Role) Del(ctx context.Context, req entity.RoleDelReq) *code.Result {
 	collection := mdb.MDB.Collection(roles.TableName())
 	id, _ := primitive.ObjectIDFromHex(req.Id)
 	_, err := collection.DeleteOne(ctx, bson.M{"_id": id})
-	if err != nil {
-		mhayaLogger.Warnf("Del DeleteOne error:", err)
-		return common.NewResult(code.InternalError)
-	}
-
-	return nil
+	return err
 }
 
 // AddRoleAccess  添加角色权限
-func (r *Role) AddRoleAccess(ctx context.Context, req entity.RoleAccessAddReq) *code.Result {
+func (r *Role) AddRoleAccess(ctx context.Context, req entity.RoleAccessAddReq) error {
 	// 检查上下文是否有效
 	if ctx.Err() != nil {
-		mhayaLogger.Warnf("AddRoleAccess ctx error:", ctx.Err())
-		return common.NewResult(code.InternalError)
+		return ctx.Err()
 	}
-
 	// 检查角色是否存在
 	roles := models.Roles{}
 	collection := mdb.MDB.Collection(roles.TableName())
 	roleIDobj, _ := primitive.ObjectIDFromHex(req.RoleId)
 	if err := collection.FindOne(ctx, bson.M{"_id": roleIDobj}).Err(); err != nil {
 		if errors.Is(err, mongo.ErrNoDocuments) {
-			return common.NewResult(code.RoleNotExistError)
+			return fmt.Errorf("角色不存在")
 		}
 	}
 	// 检查权限是否存在 ->具体的权限规则表-存放路由、菜单等
@@ -222,7 +199,7 @@ func (r *Role) AddRoleAccess(ctx context.Context, req entity.RoleAccessAddReq) *
 	filter := bson.M{"_id": bson.M{"$in": accessIDS}} // 数组查询
 	if err := collection.FindOne(ctx, filter).Err(); err != nil {
 		if errors.Is(err, mongo.ErrNoDocuments) {
-			return common.NewResult(code.AccessNotExistError)
+			return fmt.Errorf("权限不存在")
 		}
 	}
 	// 插入新角色权限记录
@@ -231,48 +208,40 @@ func (r *Role) AddRoleAccess(ctx context.Context, req entity.RoleAccessAddReq) *
 	collection = mdb.MDB.Collection(roleAccess.TableName())
 	_, insertErr := collection.UpdateOne(ctx, bson.M{"role_id": req.RoleId}, bson.M{"$addToSet": bson.M{"access_id": bson.M{"$each": req.AccessId}}}, options.Update().SetUpsert(true))
 	if insertErr != nil {
-		mhayaLogger.Warnf("AddRoleAccess UpdateOne error:", insertErr)
-		return common.NewResult(code.InternalError)
+		log.Printf("Failed to insert role: %s", insertErr)
+		return insertErr
 	}
 	return nil
 }
 
 // UpdateRoleAccess 修改角色权限
-func (r *Role) UpdateRoleAccess(ctx context.Context, req entity.RoleAccessUpdateReq) *code.Result {
+func (r *Role) UpdateRoleAccess(ctx context.Context, req entity.RoleAccessUpdateReq) error {
 	// 验证请求数据的有效性
-	err := validateConcurrently(ctx, req)
-	if err != nil {
-		mhayaLogger.Warnf("UpdateRoleAccess validateConcurrently error:", err)
-		return common.NewResult(code.InternalError)
+	if err := validateConcurrently(ctx, req); err != nil {
+		return err
 	}
-
 	// 更新角色权限
-	err = r.updateAccessInDatabase(ctx, req)
-	if err != nil {
-		mhayaLogger.Warnf("UpdateRoleAccess updateAccessInDatabase error:", err)
-		return common.NewResult(code.InternalError)
+	if err := r.updateAccessInDatabase(ctx, req); err != nil {
+		return err
 	}
-
 	// 返回成功
 	return nil
 }
 
 // DelRoleAccess 根据角色ID删除角色权限
-func (r *Role) DelRoleAccess(ctx context.Context, req entity.RoleAccessDelReq) *code.Result {
+func (r *Role) DelRoleAccess(ctx context.Context, req entity.RoleAccessDelReq) error {
 	roleAccess := models.RoleAccess{}
 	collection := mdb.MDB.Collection(roleAccess.TableName())
 	filter := bson.M{"role_id": req.RoleId}
 	_, err := collection.DeleteOne(ctx, filter)
 	if err != nil {
-		mhayaLogger.Warnf("DelRoleAccess DeleteOne error:", err)
-		return common.NewResult(code.InternalError)
+		return err
 	}
-
 	return nil
 }
 
 // GetRoleAccessList 获取角色权限列表根据角色ID
-func (r *Role) GetRoleAccessList(ctx context.Context, req entity.RoleAccessListReq) (*entity.AccessResp, *code.Result) {
+func (r *Role) GetRoleAccessList(ctx context.Context, req entity.RoleAccessListReq) ([]*entity.AccessResp, error) {
 	// 查询角色权限列表
 	roleAccess := models.RoleAccess{}
 	collection := mdb.MDB.Collection(roleAccess.TableName())
@@ -280,16 +249,14 @@ func (r *Role) GetRoleAccessList(ctx context.Context, req entity.RoleAccessListR
 	cursor, err := collection.Find(ctx, filter)
 	defer cursor.Close(ctx)
 	if err != nil {
-		mhayaLogger.Warnf("GetRoleAccessList Find error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
-
 	var accessIDS []string
 	for cursor.Next(ctx) {
 		var roleAccess models.RoleAccess
 		if err := cursor.Decode(&roleAccess); err != nil {
-			mhayaLogger.Warnf("GetRoleAccessList Decode error:", err)
-			return nil, common.NewResult(code.InternalError)
+			log.Printf("Failed to decode document: %v", err)
+			return nil, err
 		}
 
 		accessIDS = append(accessIDS, roleAccess.AccessID...)
@@ -311,17 +278,16 @@ func (r *Role) GetRoleAccessList(ctx context.Context, req entity.RoleAccessListR
 	cursor, err = collection.Find(ctx, accessFilter)
 	defer cursor.Close(ctx)
 	if err != nil {
-		mhayaLogger.Warnf("GetRoleAccessList sub Find error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
-	var accessList []*entity.AccessDetail
+	var accessList []*entity.AccessResp
 	for cursor.Next(ctx) {
 		var accesss *models.Access
 		if err := cursor.Decode(&accesss); err != nil {
-			mhayaLogger.Warnf("GetRoleAccessList sub Decode error:", err)
-			return nil, common.NewResult(code.InternalError)
+			log.Printf("Failed to decode document: %v", err)
+			return nil, err
 		}
-		accessList = append(accessList, &entity.AccessDetail{
+		accessList = append(accessList, &entity.AccessResp{
 			ID:          accesss.ID,
 			ActionName:  accesss.ActionName,
 			ModuleName:  accesss.ModuleName,
@@ -334,18 +300,13 @@ func (r *Role) GetRoleAccessList(ctx context.Context, req entity.RoleAccessListR
 		})
 	}
 	// 格式化数据并且按照下级关系组合
-	details := formatAccessData(accessList)
-
-	return &entity.AccessResp{
-		Details: details,
-		Total:   0,
-	}, nil
+	return formatAccessData(accessList), nil
 }
 
 // formatAccessData formats and organizes access data into a hierarchical structure
-func formatAccessData(accessData []*entity.AccessDetail) []*entity.AccessDetail {
-	nodeMap := make(map[interface{}]*entity.AccessDetail)
-	var rootNodes []*entity.AccessDetail
+func formatAccessData(accessData []*entity.AccessResp) []*entity.AccessResp {
+	nodeMap := make(map[interface{}]*entity.AccessResp)
+	var rootNodes []*entity.AccessResp
 	for i := range accessData {
 		node := accessData[i]
 		nodeMap[node.ID] = node
@@ -364,33 +325,25 @@ func formatAccessData(accessData []*entity.AccessDetail) []*entity.AccessDetail
 }
 
 // AddAccess 添加权限路由
-func (r *Role) AddAccess(ctx context.Context, req entity.AccessAddReq) *code.Result {
+func (r *Role) AddAccess(ctx context.Context, req entity.AccessAddReq) error {
 	// 检查上下文是否有效
 	if ctx.Err() != nil {
-		mhayaLogger.Warnf("AddAccess ctx error:", ctx.Err())
-		return common.NewResult(code.InternalError)
+		return ctx.Err()
 	}
-
 	access := models.Access{}
 	collection := mdb.MDB.Collection(access.TableName())
 	// 判断是否有相同的数据
 	filter := bson.M{"path": req.URL}
 	if err := collection.FindOne(ctx, filter).Err(); err == nil {
-		return common.NewResult(code.AccessExistError)
+		return fmt.Errorf("权限已存在")
 	}
-
 	// 插入新角色权限记录
 	_, err := collection.InsertOne(ctx, req)
-	if err != nil {
-		mhayaLogger.Warnf("AddAccess InsertOne error:", err)
-		return common.NewResult(code.InternalError)
-	}
-
-	return nil
+	return err
 }
 
 // DelAccess 删除权限路由
-func (r *Role) DelAccess(ctx context.Context, req entity.AccessDelReq) *code.Result {
+func (r *Role) DelAccess(ctx context.Context, req entity.AccessDelReq) error {
 	access := models.Access{}
 	collection := mdb.MDB.Collection(access.TableName())
 	// 判断是否有角色使用了该权限路由
@@ -398,22 +351,16 @@ func (r *Role) DelAccess(ctx context.Context, req entity.AccessDelReq) *code.Res
 	collection = mdb.MDB.Collection(roleAccess.TableName())
 	filter := bson.M{"access_id": bson.M{"$in": req.Id}} // 数组查询
 	if err := collection.FindOne(ctx, filter).Err(); err == nil {
-		return common.NewResult(code.AccessHasUsedError)
+		return fmt.Errorf("权限已被角色使用，无法删除")
 	}
-
 	objID := primitive.ObjectID{}
 	objID, _ = primitive.ObjectIDFromHex(req.Id)
 	_, err := mdb.MDB.Collection(access.TableName()).DeleteOne(ctx, bson.M{"_id": objID})
-	if err != nil {
-		mhayaLogger.Warnf("DelAccess DeleteOne error:", err)
-		return common.NewResult(code.InternalError)
-	}
-
-	return nil
+	return err
 }
 
 // UpdateAccess  修改权限路由
-func (r *Role) UpdateAccess(ctx context.Context, req entity.AccessUpdateReq) *code.Result {
+func (r *Role) UpdateAccess(ctx context.Context, req entity.AccessUpdateReq) error {
 	access := models.Access{}
 	collection := mdb.MDB.Collection(access.TableName())
 	// update
@@ -428,28 +375,22 @@ func (r *Role) UpdateAccess(ctx context.Context, req entity.AccessUpdateReq) *co
 		"status":      req.Status}
 	// 检查是否有需要更新的字段
 	if len(updateFields) == 0 {
-		mhayaLogger.Warnf("UpdateAccess len(updateFields) == 0")
-		return nil
+		return errors.New("no fields to update")
 	}
-
 	// 确保 req.Id 是一个有效的 ObjectID
 	objID, err := primitive.ObjectIDFromHex(req.Id)
 	if err != nil {
-		mhayaLogger.Warnf("UpdateAccess invalid ObjectID:%s, error:", req.Id, err)
-		return common.NewResult(code.ParamError)
+		return fmt.Errorf("invalid ObjectID: %v", err)
 	}
-
 	_, err = collection.UpdateByID(ctx, objID, bson.M{"$set": updateFields})
 	if err != nil {
-		mhayaLogger.Warnf("UpdateAccess UpdateByID error:", err)
-		return common.NewResult(code.InternalError)
+		return fmt.Errorf("update failed: %v", err)
 	}
-
-	return nil
+	return err
 }
 
 // ListAccess listAccessa
-func (r *Role) ListAccess(ctx context.Context, req entity.AccessListReq) (*entity.AccessResp, *code.Result) {
+func (r *Role) ListAccess(ctx context.Context, req *entity.AccessListReq) ([]*entity.AccessResp, error) {
 	access := models.Access{}
 	collection := mdb.MDB.Collection(access.TableName())
 	filter := bson.M{}
@@ -473,35 +414,29 @@ func (r *Role) ListAccess(ctx context.Context, req entity.AccessListReq) (*entit
 	}
 	// 数据验证
 	if req.Page <= 0 || req.Size <= 0 {
-		mhayaLogger.Warnf("ListAccess param error, req.Page:%d, req.Size:%d", req.Page, req.Size)
-		return nil, common.NewResult(code.ParamError)
+		return nil, fmt.Errorf("invalid page or size")
 	}
-
 	// 设置分页选项
 	findOptions := options.Find().SetSkip(int64((req.Page - 1) * req.Size)).SetLimit(int64(req.Size))
 	findOptions.SetSort(bson.M{"add_time": -1})
 	countDocuments, err := collection.CountDocuments(ctx, filter)
 	if err != nil {
-		mhayaLogger.Warnf("ListAccess CountDocuments error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
-
+	req.Count = countDocuments
 	cursor, err := collection.Find(ctx, filter, findOptions)
 	defer cursor.Close(ctx)
 	if err != nil {
-		mhayaLogger.Warnf("ListAccess Find error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
-
-	var accessList []*entity.AccessDetail
+	var accessList []*entity.AccessResp
 	for cursor.Next(ctx) {
 		var accesss *models.Access
 		if err := cursor.Decode(&accesss); err != nil {
-			mhayaLogger.Warnf("ListAccess Decode error:", err)
-			return nil, common.NewResult(code.InternalError)
+			log.Printf("Failed to decode document: %v", err)
+			return nil, err
 		}
-
-		accessList = append(accessList, &entity.AccessDetail{
+		accessList = append(accessList, &entity.AccessResp{
 			ID:          accesss.ID,
 			ActionName:  accesss.ActionName,
 			ModuleName:  accesss.ModuleName,
@@ -513,14 +448,8 @@ func (r *Role) ListAccess(ctx context.Context, req entity.AccessListReq) (*entit
 			Status:      accesss.Status,
 		})
 	}
-
 	// 格式化数据并且按照下级关系组合
-	details := formatAccessData(accessList)
-
-	return &entity.AccessResp{
-		Details: details,
-		Total:   countDocuments,
-	}, nil
+	return formatAccessData(accessList), nil
 }
 
 // updateAccessInDatabase 在数据库中更新角色权限
@@ -538,7 +467,7 @@ func (r *Role) updateAccessInDatabase(ctx context.Context, req entity.RoleAccess
 }
 
 // AdminBindRole 绑定角色
-func (r *Role) AdminBindRole(ctx context.Context, req entity.AdminBindRoleReq) *code.Result {
+func (r *Role) AdminBindRole(ctx context.Context, req *entity.AdminBindRoleReq) error {
 	// 例如更新角色权限表中的记录
 	role := models.Roles{}
 	collection := mdb.MDB.Collection(role.TableName())
@@ -546,47 +475,36 @@ func (r *Role) AdminBindRole(ctx context.Context, req entity.AdminBindRoleReq) *
 	filter := bson.M{"_id": roleId, "status": 1}
 	// 判断你是否存在
 	if err := collection.FindOne(ctx, filter).Err(); err != nil {
-		mhayaLogger.Warnf("AdminBindRole Find error:", err)
-		return common.NewResult(code.RoleNotExistOrDisabledUserError)
+		return fmt.Errorf("角色不存在,或者已经被禁用")
 	}
-
 	// 判断管理员是否存在
 	admin := model.Admin{}
 	collection = mdb.MDB.Collection(admin.TableName())
 	objID, _ := primitive.ObjectIDFromHex(req.AdminId)
 	err := collection.FindOne(ctx, bson.M{"_id": objID}).Decode(&admin)
 	if err != nil {
-		return common.NewResult(code.AdminNotExistError)
+		return fmt.Errorf("管理员不存在")
 	}
-
 	if admin.RoleId == req.RoleId {
-		mhayaLogger.Warnf("管理员角色和请求角色一致，无需修改")
-		return nil
+		return fmt.Errorf("管理员角色和请求角色一致，无需修改")
 	}
-
 	if admin.Username == "admin" {
-		mhayaLogger.Warnf("admin-超级账户不能修改角色")
-		return common.NewResult(code.AdminMustNotUpdateError)
+		return fmt.Errorf("admin-超级账户不能修改角色")
 	}
-
 	filter = bson.M{"_id": objID, "status": 1}
 	if err := collection.FindOne(ctx, filter).Err(); err != nil {
-		mhayaLogger.Warnf("管理员不存在 或者 已经被禁用")
-		return common.NewResult(code.RoleNotExistOrDisabledUserError)
+		return fmt.Errorf("管理员不存在 或者 已经被禁用")
 	}
-
 	// 更新管理员数据
 	_, err = collection.UpdateByID(ctx, objID, bson.M{"$set": bson.M{"role_id": req.RoleId}})
 	if err != nil {
-		mhayaLogger.Warnf("AdminBindRole UpdateByID error:", err)
-		return common.NewResult(code.InternalError)
+		return fmt.Errorf("更新管理员失败")
 	}
-
 	return nil // 假设更新成功，实际应根据业务逻辑处理
 }
 
 // AdminUnBindRole 取消绑定角色
-func (r *Role) AdminUnBindRole(ctx context.Context, req entity.AdminBindRoleReq) *code.Result {
+func (r *Role) AdminUnBindRole(ctx context.Context, req *entity.AdminBindRoleReq) error {
 	// 例如更新角色权限表中的记录
 	admin := model.Admin{}
 	collection := mdb.MDB.Collection(admin.TableName())
@@ -594,26 +512,20 @@ func (r *Role) AdminUnBindRole(ctx context.Context, req entity.AdminBindRoleReq)
 	filter := bson.M{"_id": objID}
 	err := collection.FindOne(ctx, filter).Decode(&admin)
 	if err != nil {
-		return common.NewResult(code.AdminNotExistError)
+		return fmt.Errorf("管理员不存在")
 	}
 
 	if admin.RoleId == req.RoleId {
-		mhayaLogger.Warnf("管理员角色和请求角色一致，无需修改")
-		return nil
+		return fmt.Errorf("管理员角色和请求角色一致，无需修改")
 	}
-
 	if admin.Username == "admin" {
-		mhayaLogger.Warnf("admin-超级账户不能修改角色")
-		return common.NewResult(code.AdminMustNotUpdateError)
+		return fmt.Errorf("admin-超级账户不能修改角色")
 	}
-
 	// 更新管理员数据
 	_, err = collection.UpdateByID(ctx, objID, bson.M{"$set": bson.M{"role_id": ""}})
 	if err != nil {
-		mhayaLogger.Warnf("AdminUnBindRole UpdateByID error:", err)
-		return common.NewResult(code.InternalError)
+		return fmt.Errorf("更新管理员失败")
 	}
-
 	return nil
 }
 
@@ -670,27 +582,26 @@ func getRoleAccess(ctx context.Context, roleId string) (*models.RoleAccess, erro
 	return &roleAccess, nil
 }
 
-func (r *Role) GetAdminRole(ctx context.Context, req entity.AdminBindRoleReq) (*entity.AdminBindRoleResp, *code.Result) {
+func (r *Role) GetAdminRole(ctx context.Context, req *entity.AdminBindRoleReq) (*entity.AdminBindRoleResp, error) {
+
 	if req.RoleId == "admin" {
+
 		access := models.Access{}
 		collection := mdb.MDB.Collection(access.TableName())
 		filter := bson.M{}
 		cursor, err := collection.Find(ctx, filter)
 		defer cursor.Close(ctx)
 		if err != nil {
-			mhayaLogger.Warnf("GetAdminRole Find error:", err)
-			return nil, common.NewResult(code.InternalError)
+			return nil, fmt.Errorf("查询权限失败: %v", err)
 		}
-
-		var accessList []*entity.AccessDetail
+		var accessList []*entity.AccessResp
 		for cursor.Next(ctx) {
 			var accesss *models.Access
 			err := cursor.Decode(&accesss)
 			if err != nil {
-				mhayaLogger.Warnf("GetAdminRole Decode error:", err)
-				return nil, common.NewResult(code.InternalError)
+				return nil, fmt.Errorf("解析权限数据失败: %v", err)
 			}
-			accessList = append(accessList, &entity.AccessDetail{
+			accessList = append(accessList, &entity.AccessResp{
 				ID:          accesss.ID,
 				ActionName:  accesss.ActionName,
 				Description: accesss.Description,
@@ -715,14 +626,12 @@ func (r *Role) GetAdminRole(ctx context.Context, req entity.AdminBindRoleReq) (*
 
 	role, err := getRole(ctx, req.RoleId)
 	if err != nil {
-		mhayaLogger.Warnf("GetAdminRole getRole error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
 
 	roleAccess, err := getRoleAccess(ctx, req.RoleId)
 	if err != nil {
-		mhayaLogger.Warnf("GetAdminRole getRoleAccess error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
 
 	var AccessIds []primitive.ObjectID
@@ -738,11 +647,9 @@ func (r *Role) GetAdminRole(ctx context.Context, req entity.AdminBindRoleReq) (*
 
 	if len(AccessIds) == 0 {
 		if len(invalidAccessIds) > 0 {
-			mhayaLogger.Warnf("GetAdminRole 无效的权限ID:", strings.Join(invalidAccessIds, ", "))
-			return nil, common.NewResult(code.InternalError)
+			return nil, fmt.Errorf("无效的权限ID: %v", strings.Join(invalidAccessIds, ", "))
 		}
-
-		return nil, common.NewResult(code.NoAccessError)
+		return nil, fmt.Errorf("没有权限")
 	}
 
 	access := models.Access{}
@@ -752,18 +659,17 @@ func (r *Role) GetAdminRole(ctx context.Context, req entity.AdminBindRoleReq) (*
 	cursor, err := collection.Find(ctx, filter)
 	defer cursor.Close(ctx)
 	if err != nil {
-		mhayaLogger.Warnf("GetAdminRole Find error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, fmt.Errorf("查询权限失败: %v", err)
 	}
 
-	var accessList []*entity.AccessDetail
+	var accessList []*entity.AccessResp
 	for cursor.Next(ctx) {
 		var accesss *models.Access
 		if err := cursor.Decode(&accesss); err != nil {
-			mhayaLogger.Warnf("GetAdminRole Decode error:", err)
-			return nil, common.NewResult(code.InternalError)
+			log.Printf("Failed to decode document: %v", err)
+			return nil, fmt.Errorf("解码权限失败: %v", err)
 		}
-		accessList = append(accessList, &entity.AccessDetail{
+		accessList = append(accessList, &entity.AccessResp{
 			ID:          accesss.ID,
 			ActionName:  accesss.ActionName,
 			ModuleName:  accesss.ModuleName,

game/game_cluster/nodes/webadmin/service/synthesis.go

@@ -2,16 +2,15 @@ package service
 
 import (
 	"context"
+	"errors"
+	"log"
 	"math"
 	"time"
 
-	"github.com/mhaya/game/game_cluster/internal/code"
 	"github.com/mhaya/game/game_cluster/internal/constant"
 	"github.com/mhaya/game/game_cluster/internal/mdb"
 	"github.com/mhaya/game/game_cluster/internal/mdb/models"
-	"github.com/mhaya/game/game_cluster/nodes/webadmin/common"
 	"github.com/mhaya/game/game_cluster/nodes/webadmin/entity"
-	mhayaLogger "github.com/mhaya/logger"
 	"github.com/spf13/cast"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
@@ -29,7 +28,7 @@ func NewSynthesis() *Synthesis {
 	}
 }
 
-func (s *Synthesis) FindMDBUserLogDaily(req entity.UserLogDailyReq) (*entity.UserLogDailyResp, *code.Result) {
+func (s *Synthesis) FindMDBUserLogDaily(req *entity.UserLogDailyReq) ([]entity.UserLogDailyResp, error) {
 	// 定义上下文
 	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Second)
 	defer cancel()
@@ -61,9 +60,9 @@ func (s *Synthesis) FindMDBUserLogDaily(req entity.UserLogDailyReq) (*entity.Use
 	// 计算总数
 	count, err := collection.CountDocuments(ctx, filter)
 	if err != nil {
-		mhayaLogger.Warnf("FindMDBUserLogDaily CountDocuments error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
+	req.Total = count
 
 	// 执行查询
 	opts := options.Find()
@@ -73,30 +72,28 @@ func (s *Synthesis) FindMDBUserLogDaily(req entity.UserLogDailyReq) (*entity.Use
 
 	cursor, err := collection.Find(ctx, filter, opts)
 	if err != nil {
-		mhayaLogger.Warnf("FindMDBUserLogDaily Find error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
 	defer cursor.Close(ctx)
 
 	// 解析查询结果
-	var results []*entity.UserLogDailyDetail
+	var results []entity.UserLogDailyResp
 
 	for cursor.Next(ctx) {
-		var result *entity.UserLogDailyDetail
+		var result entity.UserLogDailyResp
 		err := cursor.Decode(&result)
 		if err != nil {
-			mhayaLogger.Warnf("FindMDBUserLogDaily Decode error:", err)
-			return nil, common.NewResult(code.InternalError)
+			return nil, err
 		}
 		results = append(results, result)
 	}
 	// 同一天的数据全部放到platform= ALl 且数据累加
 	// 如果没有platform=all 的那就新增一个 同一个时间段只能有一个 platform=all
 	// 将同一天的数据累加到platform=all的记录中
-	allPlatformRecordMap := make(map[int64]*entity.UserLogDailyDetail)
+	allPlatformRecordMap := make(map[int64]*entity.UserLogDailyResp)
 
 	for _, result := range results {
-		allPlatformRecordMap[result.Timestamp] = &entity.UserLogDailyDetail{
+		allPlatformRecordMap[result.Timestamp] = &entity.UserLogDailyResp{
 			Timestamp: result.Timestamp,
 			Platform:  "all",
 		}
@@ -117,17 +114,14 @@ func (s *Synthesis) FindMDBUserLogDaily(req entity.UserLogDailyReq) (*entity.Use
 
 	// 替换原有结果
 	for _, record := range allPlatformRecordMap {
-		results = append(results, record)
+		results = append(results, *record)
 	}
 
-	return &entity.UserLogDailyResp{
-		Details: results,
-		Total:   count,
-	}, nil
+	return results, nil
 }
 
 // FindWithdrawal 根据请求查询提现记录
-func (s *Synthesis) FindWithdrawal(req entity.UserWithdrawalReq) (*entity.UserWithdrawalResp, *code.Result) {
+func (s *Synthesis) FindWithdrawal(req *entity.UserWithdrawalReq) ([]*entity.UserWithdrawalResp, int64, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Second)
 	defer cancel()
 	collection := mdb.MDB.Collection(constant.CNameCashOutRecord)
@@ -160,42 +154,32 @@ func (s *Synthesis) FindWithdrawal(req entity.UserWithdrawalReq) (*entity.UserWi
 	// 获取总数total
 	count, err := collection.CountDocuments(ctx, filter)
 	if err != nil {
-		mhayaLogger.Warnf("FindWithdrawal CountDocuments error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, 0, err
 	}
 
 	// 查询数据
-	var results []*entity.UserWithdrawalDetail
+	var results []*entity.UserWithdrawalResp
 	cursor, err := collection.Find(ctx, filter, findOptions)
 	if err != nil {
-		mhayaLogger.Warnf("FindWithdrawal Find error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, 0, err
 	}
-
 	defer cursor.Close(ctx)
 	// 解析结果
 	for cursor.Next(ctx) {
-		var result entity.UserWithdrawalDetail
+		var result entity.UserWithdrawalResp
 		if err := cursor.Decode(&result); err != nil {
-			mhayaLogger.Warnf("FindWithdrawal Decode error:", err)
-			return nil, common.NewResult(code.InternalError)
+			return nil, 0, err
 		}
 		results = append(results, &result)
 	}
-
 	if err := cursor.Err(); err != nil {
-		mhayaLogger.Warnf("FindWithdrawal cursor error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, 0, err
 	}
-
-	return &entity.UserWithdrawalResp{
-		Details: results,
-		Total:   count,
-	}, nil
+	return results, count, nil
 }
 
 // WithdrawalStatus 更新提现状态
-func (s *Synthesis) WithdrawalStatus(req entity.UserWithdrawalStatus) *code.Result {
+func (s *Synthesis) WithdrawalStatus(req *entity.UserWithdrawalStatus) error {
 	// ctx, cancel := context.WithTimeout(context.Background(), 100*time.Second)
 	// defer cancel()
 	collection := mdb.MDB.Collection(constant.CNameCashOutRecord)
@@ -209,21 +193,19 @@ func (s *Synthesis) WithdrawalStatus(req entity.UserWithdrawalStatus) *code.Resu
 	// 执行更新操作
 	_, err := collection.UpdateOne(context.TODO(), updateCondition, updateContent, updateOptions)
 	if err != nil {
-		mhayaLogger.Warnf("WithdrawalStatus UpdateOne error:", err)
-		return common.NewResult(code.InternalError)
+		return err
 	}
-
 	return nil
 }
 
 // WithdrawalStatusBatch 更新提现状态
-func (s *Synthesis) WithdrawalStatusBatch(req entity.UserWithdrawalStatusBatch) *code.Result {
+func (s *Synthesis) WithdrawalStatusBatch(req *entity.UserWithdrawalStatusBatch) error {
 	collection := mdb.MDB.Collection(constant.CNameCashOutRecord)
 	if len(req.ID) == 0 {
-		return common.NewResult(code.ParamError)
+		return errors.New("id 不能为空")
 	}
-
 	for _, id := range req.ID {
+
 		objID := primitive.ObjectID{}
 		objID, _ = primitive.ObjectIDFromHex(id)
 		updateCondition := bson.M{"_id": objID}
@@ -231,10 +213,9 @@ func (s *Synthesis) WithdrawalStatusBatch(req entity.UserWithdrawalStatusBatch)
 		withdrawal := models.CashOutRecord{}
 		err := collection.FindOne(context.TODO(), updateCondition).Decode(&withdrawal)
 		if err != nil {
-			mhayaLogger.Warnf("WithdrawalStatusBatch FindOne error:", err)
+			log.Printf("查询提现记录失败: %v", err)
 			continue
 		}
-
 		if req.Withdrawal != 0 {
 			if withdrawal.Status == 1 {
 				updateContent = bson.M{"$set": bson.M{"withdrawal": req.Withdrawal}}
@@ -242,29 +223,25 @@ func (s *Synthesis) WithdrawalStatusBatch(req entity.UserWithdrawalStatusBatch)
 				continue
 			}
 		}
-
 		if req.Status > 0 {
 			if withdrawal.Status != 0 {
 				continue
 			}
 			updateContent = bson.M{"$set": bson.M{"status": req.Status}}
 		}
-
 		updateOptions := options.Update().SetUpsert(true)
 		_, err = collection.UpdateOne(context.TODO(), updateCondition, updateContent, updateOptions)
 		if err != nil {
-			mhayaLogger.Warnf("WithdrawalStatusBatch UpdateOne error:", err)
 			continue
 		}
 	}
-
 	return nil
 }
 
 // FindUserCountryCount 查询用户国家分布
 //
 // 返回值为 UserCountryResp 的切片和错误。
-func (s *Synthesis) FindUserCountryCount() (*entity.UserCountryResp, *code.Result) {
+func (s *Synthesis) FindUserCountryCount() ([]*entity.UserCountryResp, error) {
 	// 选择数据库和集合
 	collection := mdb.MDB.Collection("playerCountryStat")
 
@@ -298,23 +275,20 @@ func (s *Synthesis) FindUserCountryCount() (*entity.UserCountryResp, *code.Resul
 	// 执行聚合查询
 	cursor, err := collection.Aggregate(context.TODO(), pipeline)
 	if err != nil {
-		mhayaLogger.Warnf("FindUserCountryCount Aggregate error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
 	defer cursor.Close(context.TODO())
 
 	// 遍历查询结果
 	var results []bson.M
 	if err := cursor.All(context.TODO(), &results); err != nil {
-		mhayaLogger.Warnf("FindUserCountryCount All error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
-
 	var totalIPCount int64
-	var data []*entity.UserCountryDetail
-	// 将结果转换为 UserCountryDetail
+	var data []*entity.UserCountryResp
+	// 将结果转换为 UserCountryResp
 	for _, r := range results {
-		var resp entity.UserCountryDetail
+		var resp entity.UserCountryResp
 		resp.Country = r["countryKey"].(string)
 		resp.IPCount = int(r["totalValue"].(int32))
 		totalIPCount += int64(resp.IPCount)
@@ -328,7 +302,7 @@ func (s *Synthesis) FindUserCountryCount() (*entity.UserCountryResp, *code.Resul
 	// 根据阈值过滤结果
 	otherCount := 0
 	otherPercentage := 0.00
-	filteredResults := make([]*entity.UserCountryDetail, 0)
+	filteredResults := make([]*entity.UserCountryResp, 0)
 	threshold := 1.00
 	for _, r := range data {
 		if r.Percentage >= threshold {
@@ -343,15 +317,13 @@ func (s *Synthesis) FindUserCountryCount() (*entity.UserCountryResp, *code.Resul
 	// 将其他国家添加到过滤后的结果中
 	if otherCount > 0 {
 		p := 100.00 - math.Round(otherPercentage*100)/100
-		filteredResults = append(filteredResults, &entity.UserCountryDetail{
+		filteredResults = append(filteredResults, &entity.UserCountryResp{
 			Country:    "other",
 			IPCount:    otherCount,
 			Percentage: math.Round(p*100) / 100,
 		})
 	}
-	return &entity.UserCountryResp{
-		Details: filteredResults,
-	}, nil
+	return filteredResults, nil
 
 }
 
@@ -360,13 +332,13 @@ func (s *Synthesis) FindUserCountryCount() (*entity.UserCountryResp, *code.Resul
 // 2. 获取指定日期范围内的活跃用户数量
 // 3. 计算留存率
 // 4. 返回结果
-func (s *Synthesis) FindUserRetention(req entity.UserRetentionReq) (*entity.UserRetentionResp, *code.Result) {
+func (s *Synthesis) FindUserRetention(req *entity.UserRetentionReq) ([]*entity.UserRetentionResp, error) {
 	playerPreserve := models.GetPlayerPreserve(req.StartTime, req.EndTime)
 	// 查询数据
-	var results []*entity.UserRetentionDetail
+	var results []*entity.UserRetentionResp
 
 	for key, v := range playerPreserve {
-		var resp entity.UserRetentionDetail
+		var resp entity.UserRetentionResp
 		var retention entity.Retention
 		for _, vv := range v {
 			if vv.ID == 1 {
@@ -405,14 +377,11 @@ func (s *Synthesis) FindUserRetention(req entity.UserRetentionReq) (*entity.User
 		results = append(results, &resp)
 	}
 
-	return &entity.UserRetentionResp{
-		Details: results,
-		Total:   req.Total,
-	}, nil
+	return results, nil
 }
 
 // FindUserLevel 用户等级统计
-func (s *Synthesis) FindUserLevel() (*entity.UserLevelCountResp, *code.Result) {
+func (s *Synthesis) FindUserLevel() ([]*entity.UserLevelCountResp, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Second)
 	defer cancel()
 	collection := mdb.MDB.Collection("playerLevelStat")
@@ -420,41 +389,34 @@ func (s *Synthesis) FindUserLevel() (*entity.UserLevelCountResp, *code.Result) {
 	// 查询所有文档
 	cursor, err := collection.Find(ctx, bson.M{})
 	if err != nil {
-		mhayaLogger.Warnf("FindUserLevel Find error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
 	defer cursor.Close(ctx)
 
-	var results []*entity.UserLevelCountDetail
+	var results []*entity.UserLevelCountResp
 	var reData []*models.PlayerLevelStat
 	for cursor.Next(ctx) {
 		var result models.PlayerLevelStat
 		if err := cursor.Decode(&result); err != nil {
-			mhayaLogger.Warnf("FindUserLevel Decode error:", err)
-			return nil, common.NewResult(code.InternalError)
+			return nil, err
 		}
 		reData = append(reData, &result)
 	}
 	if err := cursor.Err(); err != nil {
-		mhayaLogger.Warnf("FindUserLevel cursor error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
-
 	dataMap := make(map[string]int)
 	for _, v := range reData {
 		for key, v1 := range v.ServerLevel {
 			dataMap[key] += v1
 		}
 	}
-
 	for k, v := range dataMap {
-		results = append(results, &entity.UserLevelCountDetail{
+		results = append(results, &entity.UserLevelCountResp{
 			Level:     cast.ToInt(k),
 			UserCount: v,
 		})
 	}
 
-	return &entity.UserLevelCountResp{
-		Details: results,
-	}, nil
+	return results, nil
 }

game/game_cluster/nodes/webadmin/service/whitelist.go

@@ -3,14 +3,13 @@ package service
 import (
 	"context"
 	"errors"
+	"fmt"
+	"log"
 	"time"
 
-	"github.com/mhaya/game/game_cluster/internal/code"
 	"github.com/mhaya/game/game_cluster/internal/mdb"
 	"github.com/mhaya/game/game_cluster/internal/mdb/models"
-	"github.com/mhaya/game/game_cluster/nodes/webadmin/common"
 	"github.com/mhaya/game/game_cluster/nodes/webadmin/entity"
-	mhayaLogger "github.com/mhaya/logger"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -24,55 +23,48 @@ func NewWhitelist() *Whitelist {
 }
 
 // Add 添加IP白名单
-func (w *Whitelist) Add(req entity.WhitelistAddReq) *code.Result {
+func (w *Whitelist) Add(ip, de string) error {
 	whitelistModel := models.Whitelist{}
 	collection := mdb.MDB.Collection(whitelistModel.TableName())
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 	// 判断是否已经存在
-	err := collection.FindOne(ctx, bson.M{"ip": req.IP}).Decode(&whitelistModel)
+	err := collection.FindOne(ctx, bson.M{"ip": ip}).Decode(&whitelistModel)
 	if err == nil {
-		mhayaLogger.Warnf("IP %s already exists in the whitelist", req.IP)
-		return nil
+		return fmt.Errorf("IP %s already exists in the whitelist", ip)
 	}
-
 	_, err = collection.InsertOne(ctx, bson.M{
-		"ip":         req.IP,
+		"ip":         ip,
 		"created_at": time.Now().Unix(),
 		"updated_at": time.Now().Unix(),
-		"desc":       req.Desc,
+		"desc":       de,
 	})
 	if err != nil {
-		mhayaLogger.Warnf("Add inserting IP %s into whitelist error: %v", req.IP, err)
+		log.Printf("Error inserting IP %s into whitelist: %v", ip, err)
 		if errors.Is(err, mongo.ErrNoDocuments) {
-			mhayaLogger.Warnf("IP %s already exists in the whitelist", req.IP)
-			return nil
+			return fmt.Errorf("IP %s already exists in the whitelist", ip)
 		}
-
-		mhayaLogger.Warnf("Add InsertOne error:", err)
-		return common.NewResult(code.InternalError)
+		return fmt.Errorf("failed to insert IP %s into whitelist: %v", ip, err)
 	}
-
 	return nil
 }
 
 // Remove 删除IP白名单
-func (w *Whitelist) Remove(req entity.WhitelistRemoveReq) *code.Result {
+func (w *Whitelist) Remove(ip string) error {
 	whitelistModel := models.Whitelist{}
 	collection := mdb.MDB.Collection(whitelistModel.TableName())
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
-	_, err := collection.DeleteOne(ctx, bson.M{"ip": req.IP})
+	_, err := collection.DeleteOne(ctx, bson.M{"ip": ip})
 	if err != nil {
-		mhayaLogger.Warnf("Remove DeleteOne error:", err)
-		return common.NewResult(code.InternalError)
+		log.Printf("Error deleting IP %s from whitelist: %v", ip, err)
+		return fmt.Errorf("failed to delete IP %s from whitelist: %v", ip, err)
 	}
-
 	return nil
 }
 
 // Check 检查IP是否在白名单中
-func (w *Whitelist) Check(ip string) *code.Result {
+func (w *Whitelist) Check(ip string) error {
 	whitelistModel := models.Whitelist{}
 	collection := mdb.MDB.Collection(whitelistModel.TableName())
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
@@ -80,15 +72,13 @@ func (w *Whitelist) Check(ip string) *code.Result {
 	// 判断是否已经存在
 	err := collection.FindOne(ctx, bson.M{"ip": ip}).Decode(&whitelistModel)
 	if err == nil {
-		mhayaLogger.Warnf("Check FindOne error:", err)
-		return common.NewResult(code.InternalError)
+		return fmt.Errorf("IP %s already exists in the whitelist", ip)
 	}
-
 	return nil
 }
 
 // GetAll 获取所有白名单数据
-func (w *Whitelist) GetAll(req entity.WhitelistListReq) (*entity.WhitelistListResp, *code.Result) {
+func (w *Whitelist) GetAll(req *entity.WhitelistListReq) ([]models.Whitelist, error) {
 	// 定义集合
 	whitelistModel := models.Whitelist{}
 	collection := mdb.MDB.Collection(whitelistModel.TableName())
@@ -112,16 +102,15 @@ func (w *Whitelist) GetAll(req entity.WhitelistListReq) (*entity.WhitelistListRe
 	findOptions := options.Find().SetSkip(int64(skip)).SetLimit(int64(pageSize))
 	count, err := collection.CountDocuments(ctx, bson.D{})
 	if err != nil {
-		mhayaLogger.Warnf("GetAll CountDocuments error:", err)
-		return nil, common.NewResult(code.InternalError)
+		return nil, err
 	}
-
+	req.Count = count
 	// 查询数据库
 	var results []models.Whitelist
 	cursor, err := collection.Find(ctx, bson.D{}, findOptions)
 	if err != nil {
-		mhayaLogger.Warnf("GetAll Find error:", err)
-		return nil, common.NewResult(code.InternalError)
+		log.Printf("Error finding documents: %v", err)
+		return nil, err
 	}
 	defer cursor.Close(ctx)
 
@@ -129,19 +118,16 @@ func (w *Whitelist) GetAll(req entity.WhitelistListReq) (*entity.WhitelistListRe
 	for cursor.Next(ctx) {
 		var whitelist models.Whitelist
 		if err := cursor.Decode(&whitelist); err != nil {
-			mhayaLogger.Warnf("GetAll Decode error:", err)
-			return nil, common.NewResult(code.InternalError)
+			log.Printf("Error decoding document: %v", err)
+			return nil, err
 		}
 		results = append(results, whitelist)
 	}
 
 	if err := cursor.Err(); err != nil {
-		mhayaLogger.Warnf("GetAll cursor error:", err)
-		return nil, common.NewResult(code.InternalError)
+		log.Printf("Cursor error: %v", err)
+		return nil, err
 	}
 
-	return &entity.WhitelistListResp{
-		Details: results,
-		Total:   count,
-	}, nil
+	return results, nil
 }