refactor: align framework cleanup with new bootstrap flow

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>

internal/handler/order.go

@@ -1,239 +0,0 @@
-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)
-}

internal/handler/task.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/go-playground/validator/v10"
 	"github.com/gofiber/fiber/v2"
 	"github.com/google/uuid"
 	"github.com/hibiken/asynq"
@@ -20,6 +21,7 @@ import (
 type TaskHandler struct {
 	queueClient *queue.Client
 	logger      *zap.Logger
+	validator   *validator.Validate
 }
 
 // NewTaskHandler 创建任务处理器实例
@@ -27,6 +29,7 @@ func NewTaskHandler(queueClient *queue.Client, logger *zap.Logger) *TaskHandler
 	return &TaskHandler{
 		queueClient: queueClient,
 		logger:      logger,
+		validator:   validator.New(),
 	}
 }
 
@@ -72,14 +75,14 @@ func (h *TaskHandler) SubmitEmailTask(c *fiber.Ctx) error {
 	if err := c.BodyParser(&req); err != nil {
 		h.logger.Warn("解析邮件任务请求失败",
 			zap.Error(err))
-		return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, "请求参数格式错误")
+		return errors.New(errors.CodeInvalidParam, "请求参数格式错误")
 	}
 
 	// 验证参数
-	if err := validate.Struct(&req); err != nil {
+	if err := h.validator.Struct(&req); err != nil {
 		h.logger.Warn("邮件任务参数验证失败",
 			zap.Error(err))
-		return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, err.Error())
+		return errors.New(errors.CodeInvalidParam, err.Error())
 	}
 
 	// 生成 RequestID（如果未提供）
@@ -111,7 +114,7 @@ func (h *TaskHandler) SubmitEmailTask(c *fiber.Ctx) error {
 			zap.String("to", req.To),
 			zap.String("request_id", req.RequestID),
 			zap.Error(err))
-		return response.Error(c, fiber.StatusInternalServerError, errors.CodeInternalError, "任务提交失败")
+		return errors.New(errors.CodeInternalError, "任务提交失败")
 	}
 
 	h.logger.Info("邮件任务提交成功",
@@ -141,14 +144,14 @@ func (h *TaskHandler) SubmitSyncTask(c *fiber.Ctx) error {
 	if err := c.BodyParser(&req); err != nil {
 		h.logger.Warn("解析同步任务请求失败",
 			zap.Error(err))
-		return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, "请求参数格式错误")
+		return errors.New(errors.CodeInvalidParam, "请求参数格式错误")
 	}
 
 	// 验证参数
-	if err := validate.Struct(&req); err != nil {
+	if err := h.validator.Struct(&req); err != nil {
 		h.logger.Warn("同步任务参数验证失败",
 			zap.Error(err))
-		return response.Error(c, fiber.StatusBadRequest, errors.CodeBadRequest, err.Error())
+		return errors.New(errors.CodeInvalidParam, err.Error())
 	}
 
 	// 生成 RequestID（如果未提供）
@@ -192,7 +195,7 @@ func (h *TaskHandler) SubmitSyncTask(c *fiber.Ctx) error {
 			zap.String("sync_type", req.SyncType),
 			zap.String("request_id", req.RequestID),
 			zap.Error(err))
-		return response.Error(c, fiber.StatusInternalServerError, errors.CodeInternalError, "任务提交失败")
+		return errors.New(errors.CodeInternalError, "任务提交失败")
 	}
 
 	h.logger.Info("同步任务提交成功",

internal/handler/user.go

@@ -1,250 +0,0 @@
-package handler
-
-import (
-	"strconv"
-
-	"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"
-)
-
-var validate = validator.New()
-
-// 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, "请求参数格式错误")
-	}
-
-	// 验证请求参数
-	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)
-}