manta/gofaster/backend/internal/auth/controller/user_controller.go

package controller

import (
	"net/http"
	"strconv"

	"gofaster/internal/auth/model"
	"gofaster/internal/auth/service"
	"gofaster/internal/shared/response"

	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
)

// UserController 用户控制器
type UserController struct {
	userService *service.UserService
}

// NewUserController 创建用户控制器实例
func NewUserController(userService *service.UserService) *UserController {
	return &UserController{userService: userService}
}

// ListUsers godoc
// @Summary 获取用户列表
// @Description 获取分页用户列表
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param page query int false "页码" default(1)
// @Param pageSize query int false "每页数量" default(10)
// @Success 200 {object} map[string]interface{} "用户列表"
// @Failure 400 {object} map[string]string "请求参数错误"
// @Failure 500 {object} map[string]string "服务器内部错误"
// @Router /auth/admin/users [get]
func (c *UserController) ListUsers(ctx *gin.Context) {
	// 获取分页参数，默认值 page=1, pageSize=10
	pageStr := ctx.DefaultQuery("page", "1")
	pageSizeStr := ctx.DefaultQuery("pageSize", "10")

	page, err := strconv.Atoi(pageStr)
	if err != nil || page < 1 {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "无效的页码参数")
		return
	}

	pageSize, err := strconv.Atoi(pageSizeStr)
	if err != nil || pageSize < 1 || pageSize > 100 {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "无效的每页大小参数，范围1-100")
		return
	}

	// 调用服务层获取用户列表
	users, total, err := c.userService.ListUsers(ctx.Request.Context(), page, pageSize)
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取用户列表失败", err.Error())
		return
	}

	// 返回分页结果
	response.Success(ctx, "获取用户列表成功", gin.H{
		"data":  users,
		"total": total,
		"page":  page,
		"size":  pageSize,
	})
}

// CreateUser godoc
// @Summary 创建用户
// @Description 创建新用户
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param user body model.User true "用户信息"
// @Success 201 {object} model.User "创建的用户信息"
// @Failure 400 {object} map[string]string "请求参数错误"
// @Failure 500 {object} map[string]string "服务器内部错误"
// @Router /auth/admin/users [post]

func (c *UserController) CreateUser(ctx *gin.Context) {
	var user model.User
	if err := ctx.ShouldBindJSON(&user); err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", err.Error())
		return
	}

	if err := c.userService.CreateUser(ctx.Request.Context(), &user); err != nil {
		response.Error(ctx, http.StatusInternalServerError, "创建用户失败", err.Error())
		return
	}

	response.Success(ctx, "用户创建成功", user)
}

// GetUser godoc
// @Summary 获取用户详情
// @Description 根据ID获取用户详情
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param id path int true "用户ID"
// @Success 200 {object} model.User "用户信息"
// @Failure 400 {object} map[string]string "无效的用户ID"
// @Failure 404 {object} map[string]string "用户不存在"
// @Failure 500 {object} map[string]string "服务器内部错误"
// @Router /auth/admin/users/{id} [get]
func (c *UserController) GetUser(ctx *gin.Context) {
	idStr := ctx.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "无效的用户ID")
		return
	}

	user, err := c.userService.GetUserByID(ctx.Request.Context(), uint(id))
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			response.Error(ctx, http.StatusNotFound, "用户不存在", "未找到指定ID的用户")
			return
		}
		response.Error(ctx, http.StatusInternalServerError, "获取用户信息失败", err.Error())
		return
	}

	response.Success(ctx, "获取用户信息成功", user)
}

// UpdateUser godoc
// @Summary 更新用户信息
// @Description 根据ID更新用户信息
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param id path int true "用户ID"
// @Param user body model.User true "用户信息"
// @Success 200 {object} model.User "更新后的用户信息"
// @Failure 400 {object} map[string]string "无效的用户ID或请求参数"
// @Failure 404 {object} map[string]string "用户不存在"
// @Failure 500 {object} map[string]string "服务器内部错误"
// @Router /auth/admin/users/{id} [put]
func (c *UserController) UpdateUser(ctx *gin.Context) {
	idStr := ctx.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "无效的用户ID")
		return
	}

	var user model.User
	if err := ctx.ShouldBindJSON(&user); err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", err.Error())
		return
	}

	// 确保更新的是正确的用户ID
	user.ID = uint(id)

	// 密码只能通过专门的密码修改接口修改，不允许在用户信息更新中修改
	user.Password = ""

	if err := c.userService.UpdateUser(ctx.Request.Context(), &user); err != nil {
		if err == gorm.ErrRecordNotFound {
			response.Error(ctx, http.StatusNotFound, "用户不存在", "未找到指定ID的用户")
			return
		}
		response.Error(ctx, http.StatusInternalServerError, "更新用户信息失败", err.Error())
		return
	}

	response.Success(ctx, "用户信息更新成功", user)
}

// DeleteUser godoc
// @Summary 删除用户
// @Description 根据ID删除用户
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param id path int true "用户ID"
// @Success 204 "删除成功"
// @Failure 400 {object} map[string]string "无效的用户ID"
// @Failure 404 {object} map[string]string "用户不存在"
// @Failure 500 {object} map[string]string "服务器内部错误"
// @Router /auth/admin/users/{id} [delete]
func (c *UserController) DeleteUser(ctx *gin.Context) {
	idStr := ctx.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "无效的用户ID")
		return
	}

	if err := c.userService.DeleteUser(ctx.Request.Context(), uint(id)); err != nil {
		if err == gorm.ErrRecordNotFound {
			response.Error(ctx, http.StatusNotFound, "用户不存在", "未找到指定ID的用户")
			return
		}
		response.Error(ctx, http.StatusInternalServerError, "删除用户失败", err.Error())
		return
	}

	response.Success(ctx, "用户删除成功", nil)
}