tyapi-server/internal/infrastructure/http/handlers/finance_handler.go

package handlers

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

	"tyapi-server/internal/application/finance"
	"tyapi-server/internal/application/finance/dto/commands"
	"tyapi-server/internal/application/finance/dto/queries"
	"tyapi-server/internal/shared/interfaces"
)

// FinanceHandler 财务HTTP处理器
type FinanceHandler struct {
	appService      finance.FinanceApplicationService
	responseBuilder interfaces.ResponseBuilder
	logger          *zap.Logger
}

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

// CreateWallet 创建钱包
// @Summary 创建钱包
// @Description 为用户创建新的钱包账户
// @Tags 钱包管理
// @Accept json
// @Produce json
// @Param request body commands.CreateWalletCommand true "创建钱包请求"
// @Success 201 {object} responses.WalletResponse "钱包创建成功"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 409 {object} map[string]interface{} "钱包已存在"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/finance/wallet [post]
func (h *FinanceHandler) CreateWallet(c *gin.Context) {
	var cmd commands.CreateWalletCommand
	if err := c.ShouldBindJSON(&cmd); err != nil {
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	response, err := h.appService.CreateWallet(c.Request.Context(), &cmd)
	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
// @Security Bearer
// @Success 200 {object} responses.WalletResponse "获取钱包信息成功"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 404 {object} map[string]interface{} "钱包不存在"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/finance/wallet [get]
func (h *FinanceHandler) GetWallet(c *gin.Context) {
	userID := c.GetString("user_id")
	if userID == "" {
		h.responseBuilder.Unauthorized(c, "用户未认证")
		return
	}

	query := &queries.GetWalletInfoQuery{UserID: userID}
	result, err := h.appService.GetWallet(c.Request.Context(), query)
	if err != nil {
		h.logger.Error("获取钱包信息失败",
			zap.String("user_id", userID),
			zap.Error(err),
		)
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

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

// UpdateWallet 更新钱包
// @Summary 更新钱包信息
// @Description 更新当前用户的钱包基本信息
// @Tags 钱包管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param request body commands.UpdateWalletCommand true "更新钱包请求"
// @Success 200 {object} map[string]interface{} "钱包更新成功"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/finance/wallet [put]
func (h *FinanceHandler) UpdateWallet(c *gin.Context) {
	userID := c.GetString("user_id")
	if userID == "" {
		h.responseBuilder.Unauthorized(c, "用户未认证")
		return
	}

	var cmd commands.UpdateWalletCommand
	if err := c.ShouldBindJSON(&cmd); err != nil {
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	cmd.UserID = userID

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

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

// Recharge 充值
// @Summary 钱包充值
// @Description 为钱包进行充值操作
// @Tags 钱包管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param request body commands.RechargeWalletCommand true "充值请求"
// @Success 200 {object} responses.TransactionResponse "充值成功"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/finance/wallet/recharge [post]
func (h *FinanceHandler) Recharge(c *gin.Context) {
	userID := c.GetString("user_id")
	if userID == "" {
		h.responseBuilder.Unauthorized(c, "用户未认证")
		return
	}

	var cmd commands.RechargeWalletCommand
	if err := c.ShouldBindJSON(&cmd); err != nil {
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	cmd.UserID = userID

	result, err := h.appService.Recharge(c.Request.Context(), &cmd)
	if err != nil {
		h.logger.Error("充值失败",
			zap.String("user_id", userID),
			zap.Error(err),
		)
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

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

// Withdraw 提现
// @Summary 钱包提现
// @Description 从钱包进行提现操作
// @Tags 钱包管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param request body commands.WithdrawWalletCommand true "提现请求"
// @Success 200 {object} responses.TransactionResponse "提现申请已提交"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/finance/wallet/withdraw [post]
func (h *FinanceHandler) Withdraw(c *gin.Context) {
	userID := c.GetString("user_id")
	if userID == "" {
		h.responseBuilder.Unauthorized(c, "用户未认证")
		return
	}

	var cmd commands.WithdrawWalletCommand
	if err := c.ShouldBindJSON(&cmd); err != nil {
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	cmd.UserID = userID

	result, err := h.appService.Withdraw(c.Request.Context(), &cmd)
	if err != nil {
		h.logger.Error("提现失败",
			zap.String("user_id", userID),
			zap.Error(err),
		)
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

	h.responseBuilder.Success(c, result, "提现申请已提交")
}

// WalletTransaction 钱包交易
// @Summary 钱包交易
// @Description 执行钱包内部交易操作
// @Tags 钱包管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param request body commands.WalletTransactionCommand true "交易请求"
// @Success 200 {object} responses.TransactionResponse "交易成功"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/finance/wallet/transaction [post]
func (h *FinanceHandler) WalletTransaction(c *gin.Context) {
	userID := c.GetString("user_id")
	if userID == "" {
		h.responseBuilder.Unauthorized(c, "用户未认证")
		return
	}

	var cmd commands.WalletTransactionCommand
	if err := c.ShouldBindJSON(&cmd); err != nil {
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	cmd.UserID = userID

	result, err := h.appService.WalletTransaction(c.Request.Context(), &cmd)
	if err != nil {
		h.logger.Error("钱包交易失败",
			zap.String("user_id", userID),
			zap.Error(err),
		)
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

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

// GetWalletStats 获取钱包统计
// @Summary 获取钱包统计
// @Description 获取钱包相关的统计数据
// @Tags 钱包管理
// @Accept json
// @Produce json
// @Security Bearer
// @Success 200 {object} responses.WalletStatsResponse "获取钱包统计成功"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/finance/wallet/stats [get]
func (h *FinanceHandler) GetWalletStats(c *gin.Context) {
	userID := c.GetString("user_id")
	if userID == "" {
		h.responseBuilder.Unauthorized(c, "用户未认证")
		return
	}

	result, err := h.appService.GetWalletStats(c.Request.Context())
	if err != nil {
		h.logger.Error("获取钱包统计失败",
			zap.String("user_id", userID),
			zap.Error(err),
		)
		h.responseBuilder.InternalError(c, "获取钱包统计失败")
		return
	}

	h.responseBuilder.Success(c, result, "获取钱包统计成功")
}

// CreateUserSecrets 创建用户密钥
// @Summary 创建用户密钥
// @Description 为用户创建API访问密钥
// @Tags 用户密钥管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param request body commands.CreateUserSecretsCommand true "创建密钥请求"
// @Success 201 {object} responses.UserSecretsResponse "用户密钥创建成功"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 409 {object} map[string]interface{} "密钥已存在"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/finance/secrets [post]
func (h *FinanceHandler) CreateUserSecrets(c *gin.Context) {
	userID := c.GetString("user_id")
	if userID == "" {
		h.responseBuilder.Unauthorized(c, "用户未认证")
		return
	}

	var cmd commands.CreateUserSecretsCommand
	if err := c.ShouldBindJSON(&cmd); err != nil {
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	cmd.UserID = userID

	result, err := h.appService.CreateUserSecrets(c.Request.Context(), &cmd)
	if err != nil {
		h.logger.Error("创建用户密钥失败",
			zap.String("user_id", userID),
			zap.Error(err),
		)
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

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

// GetUserSecrets 获取用户密钥
// @Summary 获取用户密钥
// @Description 获取当前用户的API访问密钥信息
// @Tags 用户密钥管理
// @Accept json
// @Produce json
// @Security Bearer
// @Success 200 {object} responses.UserSecretsResponse "获取用户密钥成功"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 404 {object} map[string]interface{} "密钥不存在"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/finance/secrets [get]
func (h *FinanceHandler) GetUserSecrets(c *gin.Context) {
	userID := c.GetString("user_id")
	if userID == "" {
		h.responseBuilder.Unauthorized(c, "用户未认证")
		return
	}

	query := &queries.GetUserSecretsQuery{UserID: userID}
	result, err := h.appService.GetUserSecrets(c.Request.Context(), query)
	if err != nil {
		h.logger.Error("获取用户密钥失败",
			zap.String("user_id", userID),
			zap.Error(err),
		)
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

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

// RegenerateAccessKey 重新生成访问密钥
// @Summary 重新生成访问密钥
// @Description 重新生成用户的API访问密钥
// @Tags 用户密钥管理
// @Accept json
// @Produce json
// @Security Bearer
// @Success 200 {object} responses.UserSecretsResponse "访问密钥重新生成成功"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 404 {object} map[string]interface{} "密钥不存在"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/finance/secrets/regenerate [post]
func (h *FinanceHandler) RegenerateAccessKey(c *gin.Context) {
	userID := c.GetString("user_id")
	if userID == "" {
		h.responseBuilder.Unauthorized(c, "用户未认证")
		return
	}

	cmd := &commands.RegenerateAccessKeyCommand{UserID: userID}
	result, err := h.appService.RegenerateAccessKey(c.Request.Context(), cmd)
	if err != nil {
		h.logger.Error("重新生成访问密钥失败",
			zap.String("user_id", userID),
			zap.Error(err),
		)
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

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

// DeactivateUserSecrets 停用用户密钥
// @Summary 停用用户密钥
// @Description 停用用户的API访问密钥
// @Tags 用户密钥管理
// @Accept json
// @Produce json
// @Security Bearer
// @Success 200 {object} map[string]interface{} "用户密钥停用成功"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 404 {object} map[string]interface{} "密钥不存在"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/finance/secrets/deactivate [post]
func (h *FinanceHandler) DeactivateUserSecrets(c *gin.Context) {
	userID := c.GetString("user_id")
	if userID == "" {
		h.responseBuilder.Unauthorized(c, "用户未认证")
		return
	}

	cmd := &commands.DeactivateUserSecretsCommand{UserID: userID}
	err := h.appService.DeactivateUserSecrets(c.Request.Context(), cmd)
	if err != nil {
		h.logger.Error("停用用户密钥失败",
			zap.String("user_id", userID),
			zap.Error(err),
		)
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

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