csxj2026/junhong_cmp_fiber
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

docs(constitution): 新增数据库设计原则(v2.4.0)

Browse Source 
在项目宪章中新增第九条原则"数据库设计原则"，明确禁止使用数据库外键约束和ORM关联标签。

主要变更：
- 新增原则IX：数据库设计原则（Database Design Principles）
- 强制要求：数据库表不得使用外键约束
- 强制要求：GORM模型不得使用ORM关联标签（foreignKey、hasMany等）
- 强制要求：表关系必须通过ID字段手动维护
- 强制要求：关联数据查询必须显式编写，避免ORM魔法
- 强制要求：时间字段由GORM处理，不使用数据库触发器

设计理念：
- 提升业务逻辑灵活性（无数据库约束限制）
- 优化高并发性能（无外键检查开销）
- 增强代码可读性（显式查询，无隐式预加载）
- 简化数据库架构和迁移流程
- 支持分布式和微服务场景

版本升级：2.3.0 → 2.4.0（MINOR）
This commit is contained in:
huang
2025-11-13 13:40:19 +08:00
parent ea0c6a8b16
commit 984ccccc63
63 changed files with 12099 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
internal/handler/health.go
View File

@@ -1,18 +1,116 @@
package handler
import (
"context"
"time"
"github.com/gofiber/fiber/v2"
"github.com/redis/go-redis/v9"
"go.uber.org/zap"
"gorm.io/gorm"
"github.com/break/junhong_cmp_fiber/pkg/logger"
"github.com/break/junhong_cmp_fiber/pkg/response"
)
// HealthCheck 健康检查处理器
// HealthHandler 健康检查处理器
type HealthHandler struct {
db *gorm.DB
redis *redis.Client
logger *zap.Logger
}
// NewHealthHandler 创建健康检查处理器实例
func NewHealthHandler(db *gorm.DB, redis *redis.Client, logger *zap.Logger) *HealthHandler {
return &HealthHandler{
db: db,
redis: redis,
logger: logger,
}
}
// Check 健康检查
// GET /health
func (h *HealthHandler) Check(c *fiber.Ctx) error {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
healthStatus := fiber.Map{
"status": "healthy",
"timestamp": time.Now().Format(time.RFC3339),
"services": fiber.Map{},
}
services := healthStatus["services"].(fiber.Map)
allHealthy := true
// 检查 PostgreSQL
sqlDB, err := h.db.DB()
if err != nil {
h.logger.Error("获取 PostgreSQL DB 实例失败", zap.Error(err))
services["postgres"] = fiber.Map{
"status": "down",
"error": err.Error(),
}
allHealthy = false
} else {
if err := sqlDB.PingContext(ctx); err != nil {
h.logger.Error("PostgreSQL Ping 失败", zap.Error(err))
services["postgres"] = fiber.Map{
"status": "down",
"error": err.Error(),
}
allHealthy = false
} else {
// 获取连接池统计信息
stats := sqlDB.Stats()
services["postgres"] = fiber.Map{
"status": "up",
"open_conns": stats.OpenConnections,
"in_use": stats.InUse,
"idle": stats.Idle,
"wait_count": stats.WaitCount,
"wait_duration": stats.WaitDuration.String(),
"max_idle_close": stats.MaxIdleClosed,
"max_lifetime_close": stats.MaxLifetimeClosed,
}
}
}
// 检查 Redis
if err := h.redis.Ping(ctx).Err(); err != nil {
h.logger.Error("Redis Ping 失败", zap.Error(err))
services["redis"] = fiber.Map{
"status": "down",
"error": err.Error(),
}
allHealthy = false
} else {
// 获取 Redis 信息
poolStats := h.redis.PoolStats()
services["redis"] = fiber.Map{
"status": "up",
"hits": poolStats.Hits,
"misses": poolStats.Misses,
"timeouts": poolStats.Timeouts,
"total_conns": poolStats.TotalConns,
"idle_conns": poolStats.IdleConns,
"stale_conns": poolStats.StaleConns,
}
}
// 设置总体状态
if !allHealthy {
healthStatus["status"] = "degraded"
h.logger.Warn("健康检查失败: 部分服务不可用")
return c.Status(fiber.StatusServiceUnavailable).JSON(healthStatus)
}
h.logger.Info("健康检查成功: 所有服务正常")
return response.Success(c, healthStatus)
}
// HealthCheck 简单健康检查(保持向后兼容)
func HealthCheck(c *fiber.Ctx) error {
logger.GetAppLogger().Info("我还活着!!!!", zap.String("time", time.Now().Format(time.RFC3339)))
return response.Success(c, fiber.Map{
"status": "healthy",
"timestamp": time.Now().Format(time.RFC3339),

239
internal/handler/order.go Normal file
View File

@@ -0,0 +1,239 @@
package handler
import (
"strconv"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/internal/service/order"
"github.com/break/junhong_cmp_fiber/pkg/errors"
"github.com/break/junhong_cmp_fiber/pkg/response"
"github.com/gofiber/fiber/v2"
"go.uber.org/zap"
)
// OrderHandler 订单处理器
type OrderHandler struct {
orderService *order.Service
logger *zap.Logger
}
// NewOrderHandler 创建订单处理器实例
func NewOrderHandler(orderService *order.Service, logger *zap.Logger) *OrderHandler {
return &OrderHandler{
orderService: orderService,
logger: logger,
}
}
// CreateOrder 创建订单
// POST /api/v1/orders
func (h *OrderHandler) CreateOrder(c *fiber.Ctx) error {
var req model.CreateOrderRequest
// 解析请求体
if err := c.BodyParser(&req); err != nil {
h.logger.Warn("解析请求体失败",
zap.String("path", c.Path()),
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, "请求参数格式错误")
}
// 验证请求参数
if err := validate.Struct(&req); err != nil {
h.logger.Warn("参数验证失败",
zap.String("path", c.Path()),
zap.Any("request", req),
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, err.Error())
}
// 调用服务层创建订单
orderResp, err := h.orderService.CreateOrder(c.Context(), &req)
if err != nil {
if e, ok := err.(*errors.AppError); ok {
httpStatus := fiber.StatusInternalServerError
if e.Code == errors.CodeNotFound {
httpStatus = fiber.StatusNotFound
}
return response.Error(c, httpStatus, e.Code, e.Message)
}
h.logger.Error("创建订单失败",
zap.String("order_id", req.OrderID),
zap.Error(err))
return response.Error(c, fiber.StatusInternalServerError, errors.CodeInternalError, "创建订单失败")
}
h.logger.Info("订单创建成功",
zap.Uint("order_id", orderResp.ID),
zap.String("order_no", orderResp.OrderID))
return response.Success(c, orderResp)
}
// GetOrder 获取订单详情
// GET /api/v1/orders/:id
func (h *OrderHandler) GetOrder(c *fiber.Ctx) error {
// 获取路径参数
idStr := c.Params("id")
id, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
h.logger.Warn("订单ID格式错误",
zap.String("id", idStr),
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, "订单ID格式错误")
}
// 调用服务层获取订单
orderResp, err := h.orderService.GetOrderByID(c.Context(), uint(id))
if err != nil {
if e, ok := err.(*errors.AppError); ok {
httpStatus := fiber.StatusInternalServerError
if e.Code == errors.CodeNotFound {
httpStatus = fiber.StatusNotFound
}
return response.Error(c, httpStatus, e.Code, e.Message)
}
h.logger.Error("获取订单失败",
zap.Uint("order_id", uint(id)),
zap.Error(err))
return response.Error(c, fiber.StatusInternalServerError, errors.CodeInternalError, "获取订单失败")
}
return response.Success(c, orderResp)
}
// UpdateOrder 更新订单信息
// PUT /api/v1/orders/:id
func (h *OrderHandler) UpdateOrder(c *fiber.Ctx) error {
// 获取路径参数
idStr := c.Params("id")
id, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
h.logger.Warn("订单ID格式错误",
zap.String("id", idStr),
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, "订单ID格式错误")
}
var req model.UpdateOrderRequest
// 解析请求体
if err := c.BodyParser(&req); err != nil {
h.logger.Warn("解析请求体失败",
zap.String("path", c.Path()),
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, "请求参数格式错误")
}
// 验证请求参数
if err := validate.Struct(&req); err != nil {
h.logger.Warn("参数验证失败",
zap.String("path", c.Path()),
zap.Any("request", req),
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, err.Error())
}
// 调用服务层更新订单
orderResp, err := h.orderService.UpdateOrder(c.Context(), uint(id), &req)
if err != nil {
if e, ok := err.(*errors.AppError); ok {
httpStatus := fiber.StatusInternalServerError
if e.Code == errors.CodeNotFound {
httpStatus = fiber.StatusNotFound
}
return response.Error(c, httpStatus, e.Code, e.Message)
}
h.logger.Error("更新订单失败",
zap.Uint("order_id", uint(id)),
zap.Error(err))
return response.Error(c, fiber.StatusInternalServerError, errors.CodeInternalError, "更新订单失败")
}
h.logger.Info("订单更新成功",
zap.Uint("order_id", uint(id)))
return response.Success(c, orderResp)
}
// ListOrders 获取订单列表（分页）
// GET /api/v1/orders
func (h *OrderHandler) ListOrders(c *fiber.Ctx) error {
// 获取查询参数
page, err := strconv.Atoi(c.Query("page", "1"))
if err != nil || page < 1 {
page = 1
}
pageSize, err := strconv.Atoi(c.Query("page_size", "20"))
if err != nil || pageSize < 1 {
pageSize = 20
}
if pageSize > 100 {
pageSize = 100 // 限制最大页大小
}
// 可选的用户ID过滤
var userID uint
if userIDStr := c.Query("user_id"); userIDStr != "" {
if id, err := strconv.ParseUint(userIDStr, 10, 32); err == nil {
userID = uint(id)
}
}
// 调用服务层获取订单列表
var orders []model.Order
var total int64
if userID > 0 {
// 按用户ID查询
orders, total, err = h.orderService.ListOrdersByUserID(c.Context(), userID, page, pageSize)
} else {
// 查询所有订单
orders, total, err = h.orderService.ListOrders(c.Context(), page, pageSize)
}
if err != nil {
if e, ok := err.(*errors.AppError); ok {
return response.Error(c, fiber.StatusInternalServerError, e.Code, e.Message)
}
h.logger.Error("获取订单列表失败",
zap.Int("page", page),
zap.Int("page_size", pageSize),
zap.Uint("user_id", userID),
zap.Error(err))
return response.Error(c, fiber.StatusInternalServerError, errors.CodeInternalError, "获取订单列表失败")
}
// 构造响应
totalPages := int(total) / pageSize
if int(total)%pageSize > 0 {
totalPages++
}
listResp := model.ListOrdersResponse{
Orders: make([]model.OrderResponse, 0, len(orders)),
Page: page,
PageSize: pageSize,
Total: total,
TotalPages: totalPages,
}
// 转换为响应格式
for _, o := range orders {
listResp.Orders = append(listResp.Orders, model.OrderResponse{
ID: o.ID,
OrderID: o.OrderID,
UserID: o.UserID,
Amount: o.Amount,
Status: o.Status,
Remark: o.Remark,
PaidAt: o.PaidAt,
CompletedAt: o.CompletedAt,
CreatedAt: o.CreatedAt,
UpdatedAt: o.UpdatedAt,
})
}
return response.Success(c, listResp)
}

213
internal/handler/task.go Normal file
View File

@@ -0,0 +1,213 @@
package handler
import (
"fmt"
"time"
"github.com/gofiber/fiber/v2"
"github.com/google/uuid"
"github.com/hibiken/asynq"
"go.uber.org/zap"
"github.com/break/junhong_cmp_fiber/internal/task"
"github.com/break/junhong_cmp_fiber/pkg/constants"
"github.com/break/junhong_cmp_fiber/pkg/errors"
"github.com/break/junhong_cmp_fiber/pkg/queue"
"github.com/break/junhong_cmp_fiber/pkg/response"
)
// TaskHandler 任务处理器
type TaskHandler struct {
queueClient *queue.Client
logger *zap.Logger
}
// NewTaskHandler 创建任务处理器实例
func NewTaskHandler(queueClient *queue.Client, logger *zap.Logger) *TaskHandler {
return &TaskHandler{
queueClient: queueClient,
logger: logger,
}
}
// SubmitEmailTaskRequest 提交邮件任务请求
type SubmitEmailTaskRequest struct {
To string `json:"to" validate:"required,email"`
Subject string `json:"subject" validate:"required,min=1,max=200"`
Body string `json:"body" validate:"required,min=1"`
CC []string `json:"cc,omitempty" validate:"omitempty,dive,email"`
Attachments []string `json:"attachments,omitempty"`
RequestID string `json:"request_id,omitempty"`
}
// SubmitSyncTaskRequest 提交数据同步任务请求
type SubmitSyncTaskRequest struct {
SyncType string `json:"sync_type" validate:"required,oneof=sim_status flow_usage real_name"`
StartDate string `json:"start_date" validate:"required"`
EndDate string `json:"end_date" validate:"required"`
BatchSize int `json:"batch_size,omitempty" validate:"omitempty,min=1,max=1000"`
RequestID string `json:"request_id,omitempty"`
Priority string `json:"priority,omitempty" validate:"omitempty,oneof=critical default low"`
}
// TaskResponse 任务响应
type TaskResponse struct {
TaskID string `json:"task_id"`
Queue string `json:"queue"`
Status string `json:"status"`
}
// SubmitEmailTask 提交邮件发送任务
// @Summary 提交邮件发送任务
// @Description 异步发送邮件
// @Tags 任务
// @Accept json
// @Produce json
// @Param request body SubmitEmailTaskRequest true "邮件任务参数"
// @Success 200 {object} response.Response{data=TaskResponse}
// @Failure 400 {object} response.Response
// @Router /api/v1/tasks/email [post]
func (h *TaskHandler) SubmitEmailTask(c *fiber.Ctx) error {
var req SubmitEmailTaskRequest
if err := c.BodyParser(&req); err != nil {
h.logger.Warn("解析邮件任务请求失败",
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, "请求参数格式错误")
}
// 验证参数
if err := validate.Struct(&req); err != nil {
h.logger.Warn("邮件任务参数验证失败",
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, err.Error())
}
// 生成 RequestID（如果未提供）
if req.RequestID == "" {
req.RequestID = generateRequestID("email")
}
// 构造任务载荷
payload := &task.EmailPayload{
RequestID: req.RequestID,
To: req.To,
Subject: req.Subject,
Body: req.Body,
CC: req.CC,
Attachments: req.Attachments,
}
// 提交任务到队列
err := h.queueClient.EnqueueTask(
c.Context(),
constants.TaskTypeEmailSend,
payload,
asynq.Queue(constants.QueueDefault),
asynq.MaxRetry(constants.DefaultRetryMax),
asynq.Timeout(constants.DefaultTimeout),
)
if err != nil {
h.logger.Error("提交邮件任务失败",
zap.String("to", req.To),
zap.String("request_id", req.RequestID),
zap.Error(err))
return response.Error(c, fiber.StatusInternalServerError, errors.CodeInternalError, "任务提交失败")
}
h.logger.Info("邮件任务提交成功",
zap.String("queue", constants.QueueDefault),
zap.String("to", req.To),
zap.String("request_id", req.RequestID))
return response.SuccessWithMessage(c, TaskResponse{
TaskID: req.RequestID,
Queue: constants.QueueDefault,
Status: "queued",
}, "邮件任务已提交")
}
// SubmitSyncTask 提交数据同步任务
// @Summary 提交数据同步任务
// @Description 异步执行数据同步
// @Tags 任务
// @Accept json
// @Produce json
// @Param request body SubmitSyncTaskRequest true "同步任务参数"
// @Success 200 {object} response.Response{data=TaskResponse}
// @Failure 400 {object} response.Response
// @Router /api/v1/tasks/sync [post]
func (h *TaskHandler) SubmitSyncTask(c *fiber.Ctx) error {
var req SubmitSyncTaskRequest
if err := c.BodyParser(&req); err != nil {
h.logger.Warn("解析同步任务请求失败",
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, "请求参数格式错误")
}
// 验证参数
if err := validate.Struct(&req); err != nil {
h.logger.Warn("同步任务参数验证失败",
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, err.Error())
}
// 生成 RequestID（如果未提供）
if req.RequestID == "" {
req.RequestID = generateRequestID("sync")
}
// 设置默认批量大小
if req.BatchSize == 0 {
req.BatchSize = 100
}
// 确定队列优先级
queueName := constants.QueueDefault
if req.Priority == "critical" {
queueName = constants.QueueCritical
} else if req.Priority == "low" {
queueName = constants.QueueLow
}
// 构造任务载荷
payload := &task.DataSyncPayload{
RequestID: req.RequestID,
SyncType: req.SyncType,
StartDate: req.StartDate,
EndDate: req.EndDate,
BatchSize: req.BatchSize,
}
// 提交任务到队列
err := h.queueClient.EnqueueTask(
c.Context(),
constants.TaskTypeDataSync,
payload,
asynq.Queue(queueName),
asynq.MaxRetry(constants.DefaultRetryMax),
asynq.Timeout(constants.DefaultTimeout),
)
if err != nil {
h.logger.Error("提交同步任务失败",
zap.String("sync_type", req.SyncType),
zap.String("request_id", req.RequestID),
zap.Error(err))
return response.Error(c, fiber.StatusInternalServerError, errors.CodeInternalError, "任务提交失败")
}
h.logger.Info("同步任务提交成功",
zap.String("queue", queueName),
zap.String("sync_type", req.SyncType),
zap.String("request_id", req.RequestID))
return response.SuccessWithMessage(c, TaskResponse{
TaskID: req.RequestID,
Queue: queueName,
Status: "queued",
}, "同步任务已提交")
}
// generateRequestID 生成请求 ID
func generateRequestID(prefix string) string {
return fmt.Sprintf("%s-%s-%d", prefix, uuid.New().String(), time.Now().UnixNano())
}

261
internal/handler/user.go
View File

@@ -1,33 +1,250 @@
package handler
import (
"github.com/gofiber/fiber/v2"
"strconv"
"github.com/break/junhong_cmp_fiber/pkg/constants"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/internal/service/user"
"github.com/break/junhong_cmp_fiber/pkg/errors"
"github.com/break/junhong_cmp_fiber/pkg/response"
"github.com/go-playground/validator/v10"
"github.com/gofiber/fiber/v2"
"go.uber.org/zap"
)
// GetUsers 获取用户列表（示例受保护端点）
func GetUsers(c *fiber.Ctx) error {
// 从上下文获取用户 ID（由 auth 中间件设置）
userID := c.Locals(constants.ContextKeyUserID)
var validate = validator.New()
// 示例数据
users := []fiber.Map{
{
"id": "user-123",
"name": "张三",
"email": "zhangsan@example.com",
},
{
"id": "user-456",
"name": "李四",
"email": "lisi@example.com",
},
// UserHandler 用户处理器
type UserHandler struct {
userService *user.Service
logger *zap.Logger
}
// NewUserHandler 创建用户处理器实例
func NewUserHandler(userService *user.Service, logger *zap.Logger) *UserHandler {
return &UserHandler{
userService: userService,
logger: logger,
}
}
// CreateUser 创建用户
// POST /api/v1/users
func (h *UserHandler) CreateUser(c *fiber.Ctx) error {
var req model.CreateUserRequest
// 解析请求体
if err := c.BodyParser(&req); err != nil {
h.logger.Warn("解析请求体失败",
zap.String("path", c.Path()),
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, "请求参数格式错误")
}
return response.SuccessWithMessage(c, fiber.Map{
"users": users,
"authenticated_as": userID,
}, "success")
// 验证请求参数
if err := validate.Struct(&req); err != nil {
h.logger.Warn("参数验证失败",
zap.String("path", c.Path()),
zap.Any("request", req),
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, err.Error())
}
// 调用服务层创建用户
userResp, err := h.userService.CreateUser(c.Context(), &req)
if err != nil {
if e, ok := err.(*errors.AppError); ok {
return response.Error(c, fiber.StatusInternalServerError, e.Code, e.Message)
}
h.logger.Error("创建用户失败",
zap.String("username", req.Username),
zap.Error(err))
return response.Error(c, fiber.StatusInternalServerError, errors.CodeInternalError, "创建用户失败")
}
h.logger.Info("用户创建成功",
zap.Uint("user_id", userResp.ID),
zap.String("username", userResp.Username))
return response.Success(c, userResp)
}
// GetUser 获取用户详情
// GET /api/v1/users/:id
func (h *UserHandler) GetUser(c *fiber.Ctx) error {
// 获取路径参数
idStr := c.Params("id")
id, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
h.logger.Warn("用户ID格式错误",
zap.String("id", idStr),
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, "用户ID格式错误")
}
// 调用服务层获取用户
userResp, err := h.userService.GetUserByID(c.Context(), uint(id))
if err != nil {
if e, ok := err.(*errors.AppError); ok {
httpStatus := fiber.StatusInternalServerError
if e.Code == errors.CodeNotFound {
httpStatus = fiber.StatusNotFound
}
return response.Error(c, httpStatus, e.Code, e.Message)
}
h.logger.Error("获取用户失败",
zap.Uint("user_id", uint(id)),
zap.Error(err))
return response.Error(c, fiber.StatusInternalServerError, errors.CodeInternalError, "获取用户失败")
}
return response.Success(c, userResp)
}
// UpdateUser 更新用户信息
// PUT /api/v1/users/:id
func (h *UserHandler) UpdateUser(c *fiber.Ctx) error {
// 获取路径参数
idStr := c.Params("id")
id, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
h.logger.Warn("用户ID格式错误",
zap.String("id", idStr),
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, "用户ID格式错误")
}
var req model.UpdateUserRequest
// 解析请求体
if err := c.BodyParser(&req); err != nil {
h.logger.Warn("解析请求体失败",
zap.String("path", c.Path()),
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, "请求参数格式错误")
}
// 验证请求参数
if err := validate.Struct(&req); err != nil {
h.logger.Warn("参数验证失败",
zap.String("path", c.Path()),
zap.Any("request", req),
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, err.Error())
}
// 调用服务层更新用户
userResp, err := h.userService.UpdateUser(c.Context(), uint(id), &req)
if err != nil {
if e, ok := err.(*errors.AppError); ok {
httpStatus := fiber.StatusInternalServerError
if e.Code == errors.CodeNotFound {
httpStatus = fiber.StatusNotFound
}
return response.Error(c, httpStatus, e.Code, e.Message)
}
h.logger.Error("更新用户失败",
zap.Uint("user_id", uint(id)),
zap.Error(err))
return response.Error(c, fiber.StatusInternalServerError, errors.CodeInternalError, "更新用户失败")
}
h.logger.Info("用户更新成功",
zap.Uint("user_id", uint(id)))
return response.Success(c, userResp)
}
// DeleteUser 删除用户（软删除）
// DELETE /api/v1/users/:id
func (h *UserHandler) DeleteUser(c *fiber.Ctx) error {
// 获取路径参数
idStr := c.Params("id")
id, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
h.logger.Warn("用户ID格式错误",
zap.String("id", idStr),
zap.Error(err))
return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, "用户ID格式错误")
}
// 调用服务层删除用户
if err := h.userService.DeleteUser(c.Context(), uint(id)); err != nil {
if e, ok := err.(*errors.AppError); ok {
httpStatus := fiber.StatusInternalServerError
if e.Code == errors.CodeNotFound {
httpStatus = fiber.StatusNotFound
}
return response.Error(c, httpStatus, e.Code, e.Message)
}
h.logger.Error("删除用户失败",
zap.Uint("user_id", uint(id)),
zap.Error(err))
return response.Error(c, fiber.StatusInternalServerError, errors.CodeInternalError, "删除用户失败")
}
h.logger.Info("用户删除成功",
zap.Uint("user_id", uint(id)))
return response.Success(c, nil)
}
// ListUsers 获取用户列表（分页）
// GET /api/v1/users
func (h *UserHandler) ListUsers(c *fiber.Ctx) error {
// 获取查询参数
page, err := strconv.Atoi(c.Query("page", "1"))
if err != nil || page < 1 {
page = 1
}
pageSize, err := strconv.Atoi(c.Query("page_size", "20"))
if err != nil || pageSize < 1 {
pageSize = 20
}
if pageSize > 100 {
pageSize = 100 // 限制最大页大小
}
// 调用服务层获取用户列表
users, total, err := h.userService.ListUsers(c.Context(), page, pageSize)
if err != nil {
if e, ok := err.(*errors.AppError); ok {
return response.Error(c, fiber.StatusInternalServerError, e.Code, e.Message)
}
h.logger.Error("获取用户列表失败",
zap.Int("page", page),
zap.Int("page_size", pageSize),
zap.Error(err))
return response.Error(c, fiber.StatusInternalServerError, errors.CodeInternalError, "获取用户列表失败")
}
// 构造响应
totalPages := int(total) / pageSize
if int(total)%pageSize > 0 {
totalPages++
}
listResp := model.ListUsersResponse{
Users: make([]model.UserResponse, 0, len(users)),
Page: page,
PageSize: pageSize,
Total: total,
TotalPages: totalPages,
}
// 转换为响应格式
for _, u := range users {
listResp.Users = append(listResp.Users, model.UserResponse{
ID: u.ID,
Username: u.Username,
Email: u.Email,
Status: u.Status,
CreatedAt: u.CreatedAt,
UpdatedAt: u.UpdatedAt,
LastLoginAt: u.LastLoginAt,
})
}
return response.Success(c, listResp)
}