update 优化代码

game/config/data/codeConfig.json

@@ -12,5 +12,19 @@
   {"code":303,"message":"角色名已存在"},
   {"code":304,"message":"角色创建失败"},
   {"code":305,"message":"角色未登录"},
-  {"code":306,"message":"角色id错误"}
+  {"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-超级账户不能修改角色"}
 ]

game/game_cluster/internal/code/code.go

@@ -31,4 +31,21 @@ 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

@@ -0,0 +1,30 @@
+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,146 +22,99 @@ func NewAdmin() *Admin {
 func (a *Admin) Login(ctx *gin.Context) {
 	var req entity.AdminLoginReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
+
 	resp, err := a.sev.Login(ctx, req.Username, req.Password)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-		"data": resp,
-	})
+
+	common.PackOkResult(ctx, code.OK, resp)
 }
 
 // Add 添加管理员
 func (a *Admin) Add(ctx *gin.Context) {
 	var req entity.AdminAddReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
+
 	err := a.sev.Add(ctx, req.Username, req.Password, req.RealName, req.Pid, req.RoleId, req.Status)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-	})
+
+	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // ChangePassword 修改密码
 func (a *Admin) ChangePassword(ctx *gin.Context) {
 	var req entity.AdminChangePasswordReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
+
 	err := a.sev.ChangePassword(ctx, req.Username, req.Password)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-	})
+
+	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // Del 删除管理员
 func (a *Admin) Del(ctx *gin.Context) {
 	var req entity.AdminDelReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
+
 	err := a.sev.Delete(ctx, req.Username)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-	})
+
+	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // FindAll 获取所有管理员
 func (a *Admin) FindAll(ctx *gin.Context) {
 	var req entity.AdminFindAllReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 	}
 
-	resp, total, err := a.sev.FindAll(ctx, req.Page, req.Size, req.Username)
+	resp, err := a.sev.FindAll(ctx, req.Page, req.Size, req.Username)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code":  200,
-		"msg":   "success",
-		"data":  resp,
-		"total": total,
-	})
+
+	common.PackOkResult(ctx, code.OK, resp)
 }
 
 func (a *Admin) UpdateStatus(ctx *gin.Context) {
 	var req entity.AdminUpdateStatusReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 	}
+
 	err := a.sev.UpdateStatus(ctx, req.Username, req.Status)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-	})
 
+	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // GetServerStatus
@@ -169,16 +122,9 @@ func (a *Admin) UpdateStatus(ctx *gin.Context) {
 func (a *Admin) GetServerStatus(ctx *gin.Context) {
 	resp, err := a.sev.GetServerStatus(ctx)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		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,18 +1,21 @@
 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{}
+	return &Role{
+		sev: service.NewRole(),
+	}
 }
 
 // Add 新增角色
@@ -25,26 +28,19 @@ func NewRole() *Role {
 // @Success 200 {object} entity.Response
 // @Router /v1/admin/role/add [post]
 func (r *Role) Add(ctx *gin.Context) {
-	req := new(entity.RoleAddReq)
+	var req entity.RoleAddReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	err := new(service.Role).Add(ctx, *req)
+
+	err := r.sev.Add(ctx, req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-	})
+
+	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // List 角色列表
@@ -57,28 +53,19 @@ 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) {
-	req := new(entity.RoleListReq)
+	var req entity.RoleListReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	list, err := new(service.Role).List(ctx, req)
+
+	resp, err := r.sev.List(ctx, req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code":  200,
-		"msg":   "success",
-		"data":  list,
-		"count": req.Count,
-	})
+
+	common.PackOkResult(ctx, code.OK, resp)
 }
 
 // Update 修改角色
@@ -91,26 +78,19 @@ 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) {
-	req := new(entity.RoleUpdateReq)
+	var req entity.RoleUpdateReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	err := new(service.Role).Update(ctx, *req)
+
+	err := r.sev.Update(ctx, req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-	})
+
+	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // Del 删除角色
@@ -123,26 +103,19 @@ 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) {
-	req := new(entity.RoleDelReq)
+	var req entity.RoleDelReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	err := new(service.Role).Del(ctx, *req)
+
+	err := r.sev.Del(ctx, req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-	})
+
+	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // AddRoleAccess  添加角色权限
@@ -155,26 +128,19 @@ 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) {
-	req := new(entity.RoleAccessAddReq)
+	var req entity.RoleAccessAddReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	err := new(service.Role).AddRoleAccess(ctx, *req)
+
+	err := r.sev.AddRoleAccess(ctx, req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-	})
+
+	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // UpdateRoleAccess 修改角色权限
@@ -187,26 +153,19 @@ 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) {
-	req := new(entity.RoleAccessUpdateReq)
+	var req entity.RoleAccessUpdateReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	err := new(service.Role).UpdateRoleAccess(ctx, *req)
+
+	err := r.sev.UpdateRoleAccess(ctx, req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-	})
+
+	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // DelRoleAccess 删除角色权限
@@ -219,26 +178,19 @@ 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) {
-	req := new(entity.RoleAccessDelReq)
+	var req entity.RoleAccessDelReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	err := new(service.Role).DelRoleAccess(ctx, *req)
+
+	err := r.sev.DelRoleAccess(ctx, req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-	})
+
+	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // GetRoleAccessList 获取角色权限列表根据角色ID
@@ -251,27 +203,19 @@ 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) {
-	req := new(entity.RoleAccessListReq)
+	var req entity.RoleAccessListReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	list, err := new(service.Role).GetRoleAccessList(ctx, *req)
+
+	resp, err := r.sev.GetRoleAccessList(ctx, req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-		"data": list,
-	})
+
+	common.PackOkResult(ctx, code.OK, resp)
 }
 
 // AddAccess 添加权限路由
@@ -284,26 +228,19 @@ 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) {
-	req := new(entity.AccessAddReq)
+	var req entity.AccessAddReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	err := new(service.Role).AddAccess(ctx, *req)
+
+	err := r.sev.AddAccess(ctx, req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-	})
+
+	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // DelAccess
@@ -316,27 +253,19 @@ 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) {
-	req := new(entity.AccessDelReq)
+	var req entity.AccessDelReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	err := new(service.Role).DelAccess(ctx, *req)
+
+	err := r.sev.DelAccess(ctx, req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-	})
 
+	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // UpdateAccess  修改权限路由
@@ -349,26 +278,19 @@ 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) {
-	req := new(entity.AccessUpdateReq)
+	var req entity.AccessUpdateReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	err := new(service.Role).UpdateAccess(ctx, *req)
+
+	err := r.sev.UpdateAccess(ctx, req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-	})
+
+	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // ListAccess 获取权限路由列表
@@ -381,28 +303,19 @@ 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) {
-	req := new(entity.AccessListReq)
+	var req entity.AccessListReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	list, err := new(service.Role).ListAccess(ctx, req)
+
+	resp, err := r.sev.ListAccess(ctx, req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code":  200,
-		"msg":   "success",
-		"data":  list,
-		"total": req.Count,
-	})
+
+	common.PackOkResult(ctx, code.OK, resp)
 }
 
 // GetAdminRole
@@ -415,28 +328,19 @@ 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) {
-	req := new(entity.AdminBindRoleReq)
+	var req entity.AdminBindRoleReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	list, err := new(service.Role).GetAdminRole(ctx, req)
+
+	resp, err := r.sev.GetAdminRole(ctx, req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-		"data": list,
-	})
-	return
+
+	common.PackOkResult(ctx, code.OK, resp)
 }
 
 // AdminBindRole 绑定角色
@@ -449,27 +353,19 @@ 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) {
-	req := new(entity.AdminBindRoleReq)
+	var req entity.AdminBindRoleReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	err := new(service.Role).AdminBindRole(ctx, req)
+
+	err := r.sev.AdminBindRole(ctx, req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-	})
 
+	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // AdminUnBindRole 取消绑定角色
@@ -482,24 +378,17 @@ 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) {
-	req := new(entity.AdminBindRoleReq)
+	var req entity.AdminBindRoleReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	err := new(service.Role).AdminUnBindRole(ctx, req)
+
+	err := r.sev.AdminUnBindRole(ctx, req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(http.StatusOK, gin.H{
-		"code": 200,
-		"msg":  "success",
-	})
+
+	common.PackOkResult(ctx, code.OK, nil)
 }

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

@@ -2,6 +2,8 @@ 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"
 )
@@ -18,168 +20,107 @@ func NewSynthesis() *Synthesis {
 
 // FindUserLogDaily 查询用户日活跃
 func (s *Synthesis) FindUserLogDaily(ctx *gin.Context) {
-	req := &entity.UserLogDailyReq{}
+	var req entity.UserLogDailyReq
 	if err := ctx.ShouldBindJSON(req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
+
 	resp, err := s.sev.FindMDBUserLogDaily(req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(200, gin.H{
-		"code":  200,
-		"msg":   "success",
-		"data":  resp,
-		"total": req.Total,
-	})
+
+	common.PackOkResult(ctx, code.OK, resp)
 }
 
 // FindUserRetention 查询用户留存
 func (s *Synthesis) FindUserRetention(ctx *gin.Context) {
-	req := &entity.UserRetentionReq{}
+	var req entity.UserRetentionReq
 	if err := ctx.ShouldBindJSON(req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
+
 	resp, err := s.sev.FindUserRetention(req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		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 {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		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) {
-	req := &entity.UserWithdrawalReq{}
+	var req entity.UserWithdrawalReq
 	if err := ctx.ShouldBindJSON(req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	var total int64
-	resp, total, err := s.sev.FindWithdrawal(req)
+
+	resp, err := s.sev.FindWithdrawal(req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		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) {
-	req := &entity.UserWithdrawalStatus{}
+	var req entity.UserWithdrawalStatus
 	if err := ctx.ShouldBindJSON(req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
+
 	err := s.sev.WithdrawalStatus(req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		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) {
-	req := &entity.UserWithdrawalStatusBatch{}
+	var req entity.UserWithdrawalStatusBatch
 	if err := ctx.ShouldBindJSON(req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
+
 	err := s.sev.WithdrawalStatusBatch(req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		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 {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		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,15 +2,20 @@ 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{}
+	return &Whitelist{
+		sev: service.NewWhitelist(),
+	}
 }
 
 // GetWhitelist 获取白名单
@@ -23,28 +28,19 @@ func NewWhitelist() *Whitelist {
 // @Success 200 {object} []models.Whitelist "返回结果"
 // @Router /v1/admin/whitelist/list [post]
 func (w *Whitelist) GetWhitelist(ctx *gin.Context) {
-	req := &entity.WhitelistListReq{}
+	var req entity.WhitelistListReq
 	if err := ctx.ShouldBindJSON(req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	whitelists, err := new(service.Whitelist).GetAll(req)
+
+	resp, err := w.sev.GetAll(req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(200, gin.H{
-		"code":  200,
-		"data":  whitelists,
-		"msg":   "success",
-		"total": req.Count,
-	})
+
+	common.PackOkResult(ctx, code.OK, resp)
 }
 
 // AddWhitelist 新增白名单
@@ -57,25 +53,19 @@ 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) {
-	req := &entity.WhitelistAddReq{}
+	var req entity.WhitelistAddReq
 	if err := ctx.ShouldBindJSON(req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	err := new(service.Whitelist).Add(req.IP, req.Desc)
+
+	err := w.sev.Add(req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(200, gin.H{
-		"code": 200,
-	})
+
+	common.PackOkResult(ctx, code.OK, nil)
 }
 
 // RemoveWhitelist 删除白名单
@@ -88,23 +78,17 @@ 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) {
-	req := &entity.WhitelistRemoveReq{}
+	var req entity.WhitelistRemoveReq
 	if err := ctx.ShouldBindJSON(req); err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, code.ParamError)
 		return
 	}
-	err := new(service.Whitelist).Remove(req.IP)
+
+	err := w.sev.Remove(req)
 	if err != nil {
-		ctx.JSON(200, gin.H{
-			"code": 400,
-			"msg":  err.Error(),
-		})
+		common.PackOkResult(ctx, err.Code)
 		return
 	}
-	ctx.JSON(200, gin.H{
-		"code": 200,
-	})
+
+	common.PackOkResult(ctx, code.OK, nil)
 }

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

@@ -19,6 +19,11 @@ 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,6 +1,11 @@
 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"`
@@ -12,17 +17,22 @@ type RoleResp struct {
 }
 
 type AccessResp 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  []*AccessResp `bson:"access_item" json:"access_item"`           // 子节点
+	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"`           // 子节点
 }
 
 type RoleListReq struct {
@@ -125,9 +135,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 []*AccessResp `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 []*AccessDetail `json:"access_list"`
 }

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

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

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

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

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

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

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

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