tyapi-server/internal/domains/finance/handlers/finance_handler.go

package handlers

import (
	"github.com/gin-gonic/gin"
	"go.uber.org/zap"

	"tyapi-server/internal/domains/finance/dto"
	"tyapi-server/internal/domains/finance/services"
	"tyapi-server/internal/shared/interfaces"
)

// FinanceHandler 财务HTTP处理器
type FinanceHandler struct {
	financeService  *services.FinanceService
	responseBuilder interfaces.ResponseBuilder
	logger          *zap.Logger
}

// NewFinanceHandler 创建财务HTTP处理器
func NewFinanceHandler(
	financeService *services.FinanceService,
	responseBuilder interfaces.ResponseBuilder,
	logger *zap.Logger,
) *FinanceHandler {
	return &FinanceHandler{
		financeService:  financeService,
		responseBuilder: responseBuilder,
		logger:          logger,
	}
}

// CreateWallet 创建钱包
// @Summary 创建钱包
// @Description 为用户创建钱包
// @Tags 财务系统
// @Accept json
// @Produce json
// @Param request body dto.CreateWalletRequest true "创建钱包请求"
// @Success 201 {object} dto.CreateWalletResponse
// @Failure 400 {object} interfaces.ErrorResponse
// @Router /finance/wallet [post]
func (h *FinanceHandler) CreateWallet(c *gin.Context) {
	var req dto.CreateWalletRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.logger.Warn("创建钱包参数验证失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	response, err := h.financeService.CreateWallet(c.Request.Context(), &req)
	if err != nil {
		h.logger.Error("创建钱包失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

	h.responseBuilder.Created(c, response, "钱包创建成功")
}

// GetWallet 获取钱包信息
// @Summary 获取钱包信息
// @Description 获取用户钱包信息
// @Tags 财务系统
// @Accept json
// @Produce json
// @Param user_id query string true "用户ID"
// @Success 200 {object} dto.WalletInfo
// @Failure 400 {object} interfaces.ErrorResponse
// @Failure 404 {object} interfaces.ErrorResponse
// @Router /finance/wallet [get]
func (h *FinanceHandler) GetWallet(c *gin.Context) {
	userID := c.Query("user_id")
	if userID == "" {
		h.responseBuilder.BadRequest(c, "用户ID不能为空")
		return
	}

	wallet, err := h.financeService.GetWallet(c.Request.Context(), userID)
	if err != nil {
		h.logger.Error("获取钱包信息失败", zap.Error(err))
		h.responseBuilder.NotFound(c, err.Error())
		return
	}

	h.responseBuilder.Success(c, wallet, "获取钱包信息成功")
}

// UpdateWallet 更新钱包
// @Summary 更新钱包
// @Description 更新用户钱包信息
// @Tags 财务系统
// @Accept json
// @Produce json
// @Param request body dto.UpdateWalletRequest true "更新钱包请求"
// @Success 200 {object} interfaces.SuccessResponse
// @Failure 400 {object} interfaces.ErrorResponse
// @Failure 404 {object} interfaces.ErrorResponse
// @Router /finance/wallet [put]
func (h *FinanceHandler) UpdateWallet(c *gin.Context) {
	var req dto.UpdateWalletRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.logger.Warn("更新钱包参数验证失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	err := h.financeService.UpdateWallet(c.Request.Context(), &req)
	if err != nil {
		h.logger.Error("更新钱包失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

	h.responseBuilder.Success(c, nil, "钱包更新成功")
}

// Recharge 充值
// @Summary 钱包充值
// @Description 为用户钱包充值
// @Tags 财务系统
// @Accept json
// @Produce json
// @Param request body dto.RechargeRequest true "充值请求"
// @Success 200 {object} dto.RechargeResponse
// @Failure 400 {object} interfaces.ErrorResponse
// @Failure 404 {object} interfaces.ErrorResponse
// @Router /finance/wallet/recharge [post]
func (h *FinanceHandler) Recharge(c *gin.Context) {
	var req dto.RechargeRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.logger.Warn("充值参数验证失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	response, err := h.financeService.Recharge(c.Request.Context(), &req)
	if err != nil {
		h.logger.Error("充值失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

	h.responseBuilder.Success(c, response, "充值成功")
}

// Withdraw 提现
// @Summary 钱包提现
// @Description 从用户钱包提现
// @Tags 财务系统
// @Accept json
// @Produce json
// @Param request body dto.WithdrawRequest true "提现请求"
// @Success 200 {object} dto.WithdrawResponse
// @Failure 400 {object} interfaces.ErrorResponse
// @Failure 404 {object} interfaces.ErrorResponse
// @Router /finance/wallet/withdraw [post]
func (h *FinanceHandler) Withdraw(c *gin.Context) {
	var req dto.WithdrawRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.logger.Warn("提现参数验证失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	response, err := h.financeService.Withdraw(c.Request.Context(), &req)
	if err != nil {
		h.logger.Error("提现失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

	h.responseBuilder.Success(c, response, "提现成功")
}

// CreateUserSecrets 创建用户密钥
// @Summary 创建用户密钥
// @Description 为用户创建访问密钥
// @Tags 财务系统
// @Accept json
// @Produce json
// @Param request body dto.CreateUserSecretsRequest true "创建密钥请求"
// @Success 201 {object} dto.CreateUserSecretsResponse
// @Failure 400 {object} interfaces.ErrorResponse
// @Router /finance/secrets [post]
func (h *FinanceHandler) CreateUserSecrets(c *gin.Context) {
	var req dto.CreateUserSecretsRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.logger.Warn("创建密钥参数验证失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	response, err := h.financeService.CreateUserSecrets(c.Request.Context(), &req)
	if err != nil {
		h.logger.Error("创建密钥失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

	h.responseBuilder.Created(c, response, "密钥创建成功")
}

// GetUserSecrets 获取用户密钥
// @Summary 获取用户密钥
// @Description 获取用户访问密钥信息
// @Tags 财务系统
// @Accept json
// @Produce json
// @Param user_id query string true "用户ID"
// @Success 200 {object} dto.UserSecretsInfo
// @Failure 400 {object} interfaces.ErrorResponse
// @Failure 404 {object} interfaces.ErrorResponse
// @Router /finance/secrets [get]
func (h *FinanceHandler) GetUserSecrets(c *gin.Context) {
	userID := c.Query("user_id")
	if userID == "" {
		h.responseBuilder.BadRequest(c, "用户ID不能为空")
		return
	}

	secrets, err := h.financeService.GetUserSecrets(c.Request.Context(), userID)
	if err != nil {
		h.logger.Error("获取密钥失败", zap.Error(err))
		h.responseBuilder.NotFound(c, err.Error())
		return
	}

	h.responseBuilder.Success(c, secrets, "获取密钥成功")
}

// RegenerateAccessKey 重新生成访问密钥
// @Summary 重新生成访问密钥
// @Description 重新生成用户的访问密钥
// @Tags 财务系统
// @Accept json
// @Produce json
// @Param request body dto.RegenerateAccessKeyRequest true "重新生成密钥请求"
// @Success 200 {object} dto.RegenerateAccessKeyResponse
// @Failure 400 {object} interfaces.ErrorResponse
// @Failure 404 {object} interfaces.ErrorResponse
// @Router /finance/secrets/regenerate [post]
func (h *FinanceHandler) RegenerateAccessKey(c *gin.Context) {
	var req dto.RegenerateAccessKeyRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.logger.Warn("重新生成密钥参数验证失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	response, err := h.financeService.RegenerateAccessKey(c.Request.Context(), &req)
	if err != nil {
		h.logger.Error("重新生成密钥失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

	h.responseBuilder.Success(c, response, "密钥重新生成成功")
}

// DeactivateUserSecrets 停用用户密钥
// @Summary 停用用户密钥
// @Description 停用用户的访问密钥
// @Tags 财务系统
// @Accept json
// @Produce json
// @Param request body dto.DeactivateUserSecretsRequest true "停用密钥请求"
// @Success 200 {object} interfaces.SuccessResponse
// @Failure 400 {object} interfaces.ErrorResponse
// @Failure 404 {object} interfaces.ErrorResponse
// @Router /finance/secrets/deactivate [post]
func (h *FinanceHandler) DeactivateUserSecrets(c *gin.Context) {
	var req dto.DeactivateUserSecretsRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.logger.Warn("停用密钥参数验证失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	err := h.financeService.DeactivateUserSecrets(c.Request.Context(), &req)
	if err != nil {
		h.logger.Error("停用密钥失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

	h.responseBuilder.Success(c, nil, "密钥停用成功")
}

// WalletTransaction 钱包交易
// @Summary 钱包交易
// @Description 用户间钱包转账
// @Tags 财务系统
// @Accept json
// @Produce json
// @Param request body dto.WalletTransactionRequest true "交易请求"
// @Success 200 {object} dto.WalletTransactionResponse
// @Failure 400 {object} interfaces.ErrorResponse
// @Failure 404 {object} interfaces.ErrorResponse
// @Router /finance/wallet/transaction [post]
func (h *FinanceHandler) WalletTransaction(c *gin.Context) {
	var req dto.WalletTransactionRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.logger.Warn("交易参数验证失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	response, err := h.financeService.WalletTransaction(c.Request.Context(), &req)
	if err != nil {
		h.logger.Error("交易失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

	h.responseBuilder.Success(c, response, "交易成功")
}

// GetWalletStats 获取钱包统计
// @Summary 获取钱包统计
// @Description 获取钱包系统统计信息
// @Tags 财务系统
// @Accept json
// @Produce json
// @Success 200 {object} dto.WalletStatsResponse
// @Failure 400 {object} interfaces.ErrorResponse
// @Router /finance/wallet/stats [get]
func (h *FinanceHandler) GetWalletStats(c *gin.Context) {
	stats, err := h.financeService.GetWalletStats(c.Request.Context())
	if err != nil {
		h.logger.Error("获取钱包统计失败", zap.Error(err))
		h.responseBuilder.InternalError(c, "获取统计信息失败")
		return
	}

	h.responseBuilder.Success(c, stats, "获取统计信息成功")
}