Files
ai_dianshang/server/internal/handler/admin_user.go

558 lines
13 KiB
Go
Raw Normal View History

2025-11-17 14:11:46 +08:00
package handler
import (
"dianshang/internal/service"
"dianshang/pkg/response"
"dianshang/pkg/utils"
"strconv"
"time"
"github.com/gin-gonic/gin"
)
// AdminUserHandler 管理后台用户处理器
type AdminUserHandler struct {
userService *service.UserService
orderService *service.OrderService
}
// NewAdminUserHandler 创建管理后台用户处理器
func NewAdminUserHandler(userService *service.UserService, orderService *service.OrderService) *AdminUserHandler {
return &AdminUserHandler{
userService: userService,
orderService: orderService,
}
}
// GetUserList 获取用户列表
func (h *AdminUserHandler) GetUserList(c *gin.Context) {
page := utils.StringToInt(c.DefaultQuery("page", "1"))
// 支持两种参数名size 和 page_size
pageSize := utils.StringToInt(c.DefaultQuery("size", c.DefaultQuery("page_size", "10")))
keyword := c.Query("keyword")
status := c.Query("status")
// 支持两种参数名startDate/start_date 和 endDate/end_date
startDate := c.Query("startDate")
if startDate == "" {
startDate = c.Query("start_date")
}
endDate := c.Query("endDate")
if endDate == "" {
endDate = c.Query("end_date")
}
if page <= 0 {
page = 1
}
if pageSize <= 0 || pageSize > 100 {
pageSize = 10
}
// 构建查询条件
conditions := make(map[string]interface{})
if keyword != "" {
conditions["keyword"] = keyword
}
if status != "" {
conditions["status"] = status
}
if startDate != "" {
conditions["start_date"] = startDate
}
if endDate != "" {
conditions["end_date"] = endDate
}
users, pagination, err := h.userService.GetUserListForAdmin(page, pageSize, conditions)
if err != nil {
response.ErrorWithMessage(c, response.ERROR, err.Error())
return
}
response.Success(c, gin.H{
"list": users,
"total": pagination["total"],
"page": pagination["page"],
"page_size": pagination["page_size"],
"total_pages": pagination["total_pages"],
})
}
// GetUserDetail 获取用户详情
func (h *AdminUserHandler) GetUserDetail(c *gin.Context) {
idStr := c.Param("id")
id, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
response.BadRequest(c, "无效的用户ID")
return
}
user, err := h.userService.GetUserDetailForAdmin(uint(id))
if err != nil {
response.ErrorWithMessage(c, response.ERROR, "用户不存在")
return
}
response.Success(c, user)
}
// UpdateUserStatus 更新用户状态
func (h *AdminUserHandler) UpdateUserStatus(c *gin.Context) {
idStr := c.Param("id")
id, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
response.BadRequest(c, "无效的用户ID")
return
}
var req struct {
Status *uint8 `json:"status" binding:"required"`
Remark string `json:"remark"`
}
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, "请求参数错误")
return
}
// 获取管理员ID
adminID := uint(0)
if id, exists := c.Get("user_id"); exists {
adminID = id.(uint)
}
if err := h.userService.UpdateUserStatusByAdmin(uint(id), *req.Status, req.Remark, adminID); err != nil {
response.ErrorWithMessage(c, response.ERROR, err.Error())
return
}
response.Success(c, nil)
}
// BatchUpdateUserStatus 批量更新用户状态
func (h *AdminUserHandler) BatchUpdateUserStatus(c *gin.Context) {
var req struct {
UserIDs []uint `json:"user_ids" binding:"required"`
Status uint8 `json:"status" binding:"required"`
Remark string `json:"remark"`
}
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, "请求参数错误")
return
}
// 获取管理员ID
adminID := uint(0)
if id, exists := c.Get("user_id"); exists {
adminID = id.(uint)
}
// 批量更新用户状态
for _, userID := range req.UserIDs {
if err := h.userService.UpdateUserStatusByAdmin(userID, req.Status, req.Remark, adminID); err != nil {
response.ErrorWithMessage(c, response.ERROR, "批量更新用户状态失败")
return
}
}
response.Success(c, nil)
}
// GetUserStatistics 获取用户统计
func (h *AdminUserHandler) GetUserStatistics(c *gin.Context) {
startDate := c.Query("start_date")
endDate := c.Query("end_date")
// 如果没有提供日期默认查询最近30天
if startDate == "" || endDate == "" {
now := time.Now()
endDate = now.Format("2006-01-02")
startDate = now.AddDate(0, 0, -30).Format("2006-01-02")
}
stats, err := h.userService.GetUserStatistics(startDate, endDate)
if err != nil {
response.ErrorWithMessage(c, response.ERROR, err.Error())
return
}
response.Success(c, stats)
}
// GetUserOrders 获取用户订单列表
func (h *AdminUserHandler) GetUserOrders(c *gin.Context) {
idStr := c.Param("id")
userID, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
response.BadRequest(c, "无效的用户ID")
return
}
page := utils.StringToInt(c.DefaultQuery("page", "1"))
pageSize := utils.StringToInt(c.DefaultQuery("page_size", "10"))
if page <= 0 {
page = 1
}
if pageSize <= 0 || pageSize > 100 {
pageSize = 10
}
// 获取状态参数默认为0所有状态
status := utils.StringToInt(c.DefaultQuery("status", "0"))
orders, pagination, err := h.orderService.GetUserOrders(uint(userID), status, page, pageSize)
if err != nil {
response.ErrorWithMessage(c, response.ERROR, err.Error())
return
}
response.Success(c, gin.H{
"list": orders,
"pagination": pagination,
})
}
// GetUserOrderStatistics 获取用户订单统计
func (h *AdminUserHandler) GetUserOrderStatistics(c *gin.Context) {
idStr := c.Param("id")
userID, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
response.BadRequest(c, "无效的用户ID")
return
}
stats, err := h.orderService.GetUserOrderStatistics(uint(userID))
if err != nil {
response.ErrorWithMessage(c, response.ERROR, err.Error())
return
}
response.Success(c, stats)
}
// GetUserAddresses 获取用户地址列表
func (h *AdminUserHandler) GetUserAddresses(c *gin.Context) {
idStr := c.Param("id")
userID, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
response.BadRequest(c, "无效的用户ID")
return
}
addresses, err := h.userService.GetUserAddresses(uint(userID))
if err != nil {
response.ErrorWithMessage(c, response.ERROR, err.Error())
return
}
response.Success(c, addresses)
}
// GetUserFavorites 获取用户收藏列表
func (h *AdminUserHandler) GetUserFavorites(c *gin.Context) {
idStr := c.Param("id")
userID, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
response.BadRequest(c, "无效的用户ID")
return
}
page := utils.StringToInt(c.DefaultQuery("page", "1"))
pageSize := utils.StringToInt(c.DefaultQuery("page_size", "10"))
if page <= 0 {
page = 1
}
if pageSize <= 0 || pageSize > 100 {
pageSize = 10
}
favorites, pagination, err := h.userService.GetUserFavorites(uint(userID), page, pageSize)
if err != nil {
response.ErrorWithMessage(c, response.ERROR, err.Error())
return
}
response.Success(c, gin.H{
"list": favorites,
"pagination": pagination,
})
}
// ResetUserPassword 重置用户密码
func (h *AdminUserHandler) ResetUserPassword(c *gin.Context) {
idStr := c.Param("id")
id, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
response.BadRequest(c, "无效的用户ID")
return
}
var req struct {
NewPassword string `json:"new_password" binding:"required,min=6"`
}
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, "请求参数错误")
return
}
// 获取管理员ID
adminID := uint(0)
if id, exists := c.Get("user_id"); exists {
adminID = id.(uint)
}
if err := h.userService.ResetUserPasswordByAdmin(uint(id), req.NewPassword, adminID); err != nil {
response.ErrorWithMessage(c, response.ERROR, err.Error())
return
}
response.Success(c, nil)
}
// ExportUsers 导出用户数据
func (h *AdminUserHandler) ExportUsers(c *gin.Context) {
startDate := c.Query("start_date")
endDate := c.Query("end_date")
status := c.Query("status")
keyword := c.Query("keyword")
// 构建查询条件
conditions := make(map[string]interface{})
if status != "" {
conditions["status"] = status
}
if keyword != "" {
conditions["keyword"] = keyword
}
if startDate != "" {
conditions["start_date"] = startDate
}
if endDate != "" {
conditions["end_date"] = endDate
}
// 获取所有符合条件的用户(不分页)
users, _, err := h.userService.GetUserListForAdmin(1, 10000, conditions)
if err != nil {
response.ErrorWithMessage(c, response.ERROR, err.Error())
return
}
// 设置响应头
c.Header("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
c.Header("Content-Disposition", "attachment; filename=users_"+time.Now().Format("20060102150405")+".xlsx")
// 简单的CSV格式导出
csvData := "用户ID,昵称,手机号,邮箱,状态,注册时间\n"
for _, user := range users {
csvData += strconv.Itoa(int(user.ID)) + "," +
user.Nickname + "," +
user.Phone + "," +
user.Email + "," +
strconv.Itoa(int(user.Status)) + "," +
user.CreatedAt.Format("2006-01-02 15:04:05") + "\n"
}
c.String(200, csvData)
}
// UpdateUserProfile 更新用户资料
func (h *AdminUserHandler) UpdateUserProfile(c *gin.Context) {
idStr := c.Param("id")
id, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
response.BadRequest(c, "无效的用户ID")
return
}
var req struct {
Nickname string `json:"nickname"`
Avatar string `json:"avatar"`
Gender int `json:"gender"`
Phone string `json:"phone"`
Email string `json:"email"`
Birthday string `json:"birthday"`
}
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, "请求参数错误")
return
}
// 构建更新数据
updates := make(map[string]interface{})
if req.Nickname != "" {
updates["nickname"] = req.Nickname
}
if req.Avatar != "" {
updates["avatar"] = req.Avatar
}
if req.Gender != 0 {
updates["gender"] = req.Gender
}
if req.Phone != "" {
updates["phone"] = req.Phone
}
if req.Email != "" {
updates["email"] = req.Email
}
if req.Birthday != "" {
updates["birthday"] = req.Birthday
}
// 获取管理员ID
adminID := uint(0)
if id, exists := c.Get("user_id"); exists {
adminID = id.(uint)
}
err = h.userService.UpdateUserProfileByAdmin(uint(id), updates, adminID)
if err != nil {
response.ErrorWithMessage(c, response.ERROR, err.Error())
return
}
response.Success(c, nil)
}
// GetUserLevelInfo 获取用户等级信息
func (h *AdminUserHandler) GetUserLevelInfo(c *gin.Context) {
idStr := c.Param("id")
userID, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
response.BadRequest(c, "无效的用户ID")
return
}
levelInfo, err := h.userService.GetUserLevelInfo(uint(userID))
if err != nil {
response.ErrorWithMessage(c, response.ERROR, err.Error())
return
}
response.Success(c, levelInfo)
}
// UpdateUserLevel 更新用户等级
func (h *AdminUserHandler) UpdateUserLevel(c *gin.Context) {
idStr := c.Param("id")
id, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
response.BadRequest(c, "无效的用户ID")
return
}
var req struct {
Level uint8 `json:"level" binding:"required"`
Remark string `json:"remark"`
}
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, "请求参数错误")
return
}
// 获取管理员ID
adminID := uint(0)
if id, exists := c.Get("user_id"); exists {
adminID = id.(uint)
}
err = h.userService.UpdateUserLevelByAdmin(uint(id), req.Level, req.Remark, adminID)
if err != nil {
response.ErrorWithMessage(c, response.ERROR, err.Error())
return
}
response.Success(c, nil)
}
// GetUserLoginLogs 获取用户登录日志
func (h *AdminUserHandler) GetUserLoginLogs(c *gin.Context) {
idStr := c.Param("id")
userID, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
response.BadRequest(c, "无效的用户ID")
return
}
page := utils.StringToInt(c.DefaultQuery("page", "1"))
pageSize := utils.StringToInt(c.DefaultQuery("page_size", "10"))
if page <= 0 {
page = 1
}
if pageSize <= 0 || pageSize > 100 {
pageSize = 10
}
logs, pagination, err := h.userService.GetUserLoginLogs(uint(userID), page, pageSize)
if err != nil {
response.ErrorWithMessage(c, response.ERROR, err.Error())
return
}
response.Success(c, gin.H{
"list": logs,
"pagination": pagination,
})
}
// DeleteUser 删除用户
func (h *AdminUserHandler) DeleteUser(c *gin.Context) {
idStr := c.Param("id")
id, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
response.BadRequest(c, "无效的用户ID")
return
}
// 获取管理员ID
adminID := uint(0)
if adminIDValue, exists := c.Get("user_id"); exists {
adminID = adminIDValue.(uint)
}
err = h.userService.DeleteUserByAdmin(uint(id), adminID, "管理员删除用户")
if err != nil {
response.ErrorWithMessage(c, response.ERROR, err.Error())
return
}
response.Success(c, nil)
}
// BatchDeleteUsers 批量删除用户
func (h *AdminUserHandler) BatchDeleteUsers(c *gin.Context) {
var req struct {
IDs []uint `json:"ids" binding:"required"`
}
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, "请求参数错误")
return
}
if len(req.IDs) == 0 {
response.BadRequest(c, "用户ID列表不能为空")
return
}
// 获取管理员ID
adminID := uint(0)
if adminIDValue, exists := c.Get("user_id"); exists {
adminID = adminIDValue.(uint)
}
err := h.userService.BatchDeleteUsersByAdmin(req.IDs, adminID, "管理员批量删除用户")
if err != nil {
response.ErrorWithMessage(c, response.ERROR, err.Error())
return
}
response.Success(c, nil)
}