ycc-proxy-server/app/main/api/internal/logic/pay/paymentlogic.go

package pay

import (
	"context"
	"encoding/json"
	"fmt"
	"strconv"
	"ycc-server/app/main/api/internal/svc"
	"ycc-server/app/main/api/internal/types"
	"ycc-server/app/main/model"
	"ycc-server/common/ctxdata"
	"ycc-server/common/xerr"

	"github.com/pkg/errors"
	"github.com/redis/go-redis/v9"
	"github.com/zeromicro/go-zero/core/logx"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
)

type PaymentLogic struct {
	logx.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}
type PaymentTypeResp struct {
	amount      float64
	outTradeNo  string
	description string
}

func NewPaymentLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PaymentLogic {
	return &PaymentLogic{
		Logger: logx.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}

func (l *PaymentLogic) Payment(req *types.PaymentReq) (resp *types.PaymentResp, err error) {
	var paymentTypeResp *PaymentTypeResp
	var prepayData interface{}
	l.svcCtx.OrderModel.Trans(l.ctx, func(ctx context.Context, session sqlx.Session) error {
		switch req.PayType {
		case "agent_vip":
			paymentTypeResp, err = l.AgentVipOrderPayment(req, session)
			if err != nil {
				return err
			}

		case "query":
			paymentTypeResp, err = l.QueryOrderPayment(req, session)
			if err != nil {
				return err
			}
		}

		var createOrderErr error
		if req.PayMethod == "wechat" {
			prepayData, createOrderErr = l.svcCtx.WechatPayService.CreateWechatOrder(l.ctx, paymentTypeResp.amount, paymentTypeResp.description, paymentTypeResp.outTradeNo)
		} else if req.PayMethod == "alipay" {
			prepayData, createOrderErr = l.svcCtx.AlipayService.CreateAlipayOrder(l.ctx, paymentTypeResp.amount, paymentTypeResp.description, paymentTypeResp.outTradeNo)
		} else if req.PayMethod == "appleiap" {
			prepayData = l.svcCtx.ApplePayService.GetIappayAppID(paymentTypeResp.outTradeNo)
		}
		if createOrderErr != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 创建支付订单失败: %+v", createOrderErr)
		}
		return nil
	})
	if err != nil {
		return nil, err
	}
	switch v := prepayData.(type) {
	case string:
		// 如果 prepayData 是字符串类型，直接返回
		return &types.PaymentResp{PrepayId: v, OrderNo: paymentTypeResp.outTradeNo}, nil
	default:
		return &types.PaymentResp{PrepayData: prepayData, OrderNo: paymentTypeResp.outTradeNo}, nil
	}
}

func (l *PaymentLogic) QueryOrderPayment(req *types.PaymentReq, session sqlx.Session) (resp *PaymentTypeResp, err error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 获取用户信息失败, %+v", getUidErr)
	}
	outTradeNo := req.Id
	redisKey := fmt.Sprintf(types.QueryCacheKey, userID, outTradeNo)
	cache, cacheErr := l.svcCtx.Redis.GetCtx(l.ctx, redisKey)
	if cacheErr != nil {
		if cacheErr == redis.Nil {
			return nil, errors.Wrapf(xerr.NewErrMsg("订单已过期"), "生成订单, 缓存不存在, %+v", cacheErr)
		}
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 获取缓存失败, %+v", cacheErr)
	}
	var data types.QueryCacheLoad
	err = json.Unmarshal([]byte(cache), &data)
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 解析缓存内容失败, %v", err)
	}

	product, err := l.svcCtx.ProductModel.FindOneByProductEn(l.ctx, data.Product)
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 查找产品错误: %v", err)
	}

	var amount float64
	user, err := l.svcCtx.UserModel.FindOne(l.ctx, userID)
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "生成订单, 获取用户信息失败: %v", err)
	}

	var agentLinkModel *model.AgentLink
	if data.AgentIdentifier != "" {
		var findAgentLinkErr error
		agentLinkModel, findAgentLinkErr = l.svcCtx.AgentLinkModel.FindOneByLinkIdentifier(l.ctx, data.AgentIdentifier)
		if findAgentLinkErr != nil {
			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "生成订单, 获取代理链接失败: %+v", findAgentLinkErr)
		}
		amount = agentLinkModel.SetPrice
	} else {
		amount = product.SellPrice
	}

	if user.Inside == 1 {
		amount = 0.01
	}
	var orderID int64
	order := model.Order{
		OrderNo:         outTradeNo,
		UserId:          userID,
		ProductId:       product.Id,
		PaymentPlatform: req.PayMethod,
		PaymentScene:    "app",
		Amount:          amount,
		Status:          "pending",
	}
	orderInsertResult, insertOrderErr := l.svcCtx.OrderModel.Insert(l.ctx, session, &order)
	if insertOrderErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "生成订单, 保存订单失败: %+v", insertOrderErr)
	}
	insertedOrderID, lastInsertIdErr := orderInsertResult.LastInsertId()
	if lastInsertIdErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "生成订单, 获取保存订单ID失败: %+v", lastInsertIdErr)
	}
	orderID = insertedOrderID

	// 如果是代理推广订单，创建完整的代理订单记录
	if data.AgentIdentifier != "" && agentLinkModel != nil {
		// 获取代理信息
		agent, err := l.svcCtx.AgentModel.FindOne(l.ctx, agentLinkModel.AgentId)
		if err != nil {
			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "生成订单, 查询代理信息失败: %+v", err)
		}

		// 获取系统配置
		basePrice, err := l.getConfigFloat("base_price")
		if err != nil {
			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "生成订单, 获取基础底价配置失败: %+v", err)
		}
		priceThreshold, _ := l.getConfigFloat("price_threshold")
		priceFeeRate, _ := l.getConfigFloat("price_fee_rate")

		// 计算实际底价（基础底价+等级加成）
		levelBonus := l.getLevelBonus(agent.Level)
		actualBasePrice := basePrice + float64(levelBonus)

		// 计算提价成本
		priceCost := 0.0
		if agentLinkModel.SetPrice > priceThreshold {
			priceCost = (agentLinkModel.SetPrice - priceThreshold) * priceFeeRate
		}

		// 计算代理收益
		agentProfit := agentLinkModel.SetPrice - actualBasePrice - priceCost

		// 创建代理订单记录
		agentOrder := model.AgentOrder{
			AgentId:         agentLinkModel.AgentId,
			OrderId:         orderID,
			ProductId:       product.Id,
			OrderAmount:     amount,
			SetPrice:        agentLinkModel.SetPrice,
			ActualBasePrice: actualBasePrice,
			PriceCost:       priceCost,
			AgentProfit:     agentProfit,
			ProcessStatus:   0, // 待处理
		}
		_, agentOrderInsert := l.svcCtx.AgentOrderModel.Insert(l.ctx, session, &agentOrder)
		if agentOrderInsert != nil {
			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "生成订单, 保存代理订单失败: %+v", agentOrderInsert)
		}
	}
	return &PaymentTypeResp{amount: amount, outTradeNo: outTradeNo, description: product.ProductName}, nil
}
// AgentVipOrderPayment 代理会员充值订单（已废弃，新系统使用升级功能替代）
func (l *PaymentLogic) AgentVipOrderPayment(req *types.PaymentReq, session sqlx.Session) (resp *PaymentTypeResp, err error) {
	// 新代理系统已废弃会员充值功能，请使用升级功能
	return nil, errors.Wrapf(xerr.NewErrMsg("该功能已废弃，请使用代理升级功能"), "")
}
// getLevelBonus 获取等级加成
func (l *PaymentLogic) getLevelBonus(level int64) int64 {
	switch level {
	case 1: // 普通
		return 6
	case 2: // 黄金
		return 3
	case 3: // 钻石
		return 0
	default:
		return 0
	}
}

// getConfigFloat 获取配置值（浮点数）
func (l *PaymentLogic) getConfigFloat(configKey string) (float64, error) {
	config, err := l.svcCtx.AgentConfigModel.FindOneByConfigKey(l.ctx, configKey)
	if err != nil {
		return 0, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "获取配置失败, key: %s, %v", configKey, err)
	}
	value, err := strconv.ParseFloat(config.ConfigValue, 64)
	if err != nil {
		return 0, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "解析配置值失败, key: %s, value: %s, %v", configKey, config.ConfigValue, err)
	}
	return value, nil
}