admin/exchange_go
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1

Browse Source
This commit is contained in:
hucan
2025-02-11 14:49:16 +08:00
parent 1c5df7ad90
commit 18cbf359b7
10 changed files with 1319 additions and 612 deletions
Download Patch File Download Diff File Expand all files Collapse all files

471
services/binanceservice/futuresrest.go
View File

@ -2,15 +2,18 @@ package binanceservice
import (
"context"
"errors"
"fmt"
"go-admin/app/admin/models"
DbModels "go-admin/app/admin/models"
"go-admin/app/admin/service/dto"
"go-admin/common/const/rediskey"
"go-admin/common/global"
"go-admin/common/helper"
models2 "go-admin/models"
"go-admin/pkg/utility"
"go-admin/pkg/utility/snowflakehelper"
"strconv"
"strings"
"time"
@ -100,7 +103,6 @@ func handleFutOrderByType(db *gorm.DB, preOrder *DbModels.LinePreOrder, orderSta
//减仓回调
case preOrder.OrderType == 4 && orderStatus == 6:
handleReduceFilled(db, preOrder)
//止损成交
case preOrder.OrderType == 2 && orderStatus == 6:
handleStopLoss(db, preOrder)
@ -161,33 +163,9 @@ func handleReduceFilled(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
// 不是100%减仓 就需要挂止盈止损
if rate < 100 {
futApi := FutRestApi{}
positions, err := futApi.GetPositionV3(&apiUserInfo, preOrder.Symbol)
var num decimal.Decimal
totalNum, err := getFuturesPositionNum(apiUserInfo, preOrder, tradeSet)
if err != nil {
logger.Errorf("handleMainReduceFilled 获取持仓信息失败,交易对:%s ,订单号:%s", preOrder.Symbol, preOrder.OrderSn)
return
}
for _, item := range positions {
if item.Symbol == preOrder.Symbol {
positionAmt := utility.StrToDecimal(item.PositionAmt)
//多
if positionAmt.Cmp(decimal.Zero) > 0 && preOrder.Site == "SELL" {
num = positionAmt.Abs().Truncate(int32(tradeSet.AmountDigit))
break
} else if positionAmt.Cmp(decimal.Zero) < 0 && preOrder.Site == "BUY" {
//空
num = positionAmt.Abs().Truncate(int32(tradeSet.AmountDigit))
break
}
}
}
if num.Cmp(decimal.Zero) <= 0 {
logger.Errorf("handleMainReduceFilled 获取持仓数量为0,交易对:%s ,订单号:%s", preOrder.Symbol, preOrder.OrderSn)
return
}
@ -203,7 +181,7 @@ func handleReduceFilled(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
takeProfitOrder.CreatedAt = time.Now()
takeProfitOrder.BuyPrice = "0"
takeProfitOrder.MainOrderType = "LIMIT"
takeProfitOrder.Num = num.String()
takeProfitOrder.Num = totalNum.String()
orders = append(orders, takeProfitOrder)
//有止损单
@ -220,7 +198,7 @@ func handleReduceFilled(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
stoploss.BuyPrice = "0"
stoploss.Rate = "100"
stoploss.MainOrderType = "LIMIT"
stoploss.Num = num.String()
stoploss.Num = totalNum.String()
orders = append(orders, stoploss)
}
@ -230,23 +208,12 @@ func handleReduceFilled(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
return
}
spotApi := SpotRestApi{}
paramsMap := OrderPlacementService{
ApiId: takeProfitOrder.ApiId,
Symbol: takeProfitOrder.Symbol,
Side: takeProfitOrder.Site,
Type: "LIMIT",
TimeInForce: "GTC",
Price: utility.StrToDecimal(takeProfitOrder.Price),
Quantity: num,
NewClientOrderId: takeProfitOrder.OrderSn,
StopPrice: utility.StrToDecimal(takeProfitOrder.Price),
}
if err := spotApi.OrderPlace(db, paramsMap); err != nil {
logger.Errorf("减仓后重下止盈失败 减仓order_sn:%s err:%v", preOrder.OrderSn, err)
if err2 := db.Model(&takeProfitOrder).Updates(map[string]interface{}{"status": 2, "": err.Error()}).Error; err2 != nil {
logger.Errorf("handleMainReduceFilled 更新止盈单失败:%v", err2)
futApi := FutRestApi{}
for _, v := range orders {
if v.OrderType == 1 {
processFutTakeProfitOrder(db, futApi, v, totalNum)
} else if v.OrderType == 2 {
processFutStopLossOrder(db, v, utility.StrToDecimal(v.Price), totalNum)
}
}
}
@ -259,7 +226,7 @@ func handleReduceFilled(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
return
}
keySpotAddPosition := fmt.Sprintf(rediskey.SpotAddPositionList, global.EXCHANGE_BINANCE)
keyFutAddpositionKey := fmt.Sprintf(rediskey.FuturesAddPositionList, global.EXCHANGE_BINANCE)
addPositionData := AddPositionList{
MainId: addPositionOrder.MainId,
@ -278,199 +245,121 @@ func handleReduceFilled(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
return
}
if err := helper.DefaultRedis.RPushList(keySpotAddPosition, addVal); err != nil {
if err := helper.DefaultRedis.RPushList(keyFutAddpositionKey, addVal); err != nil {
logger.Errorf("handleMainReduceFilled 添加加仓单失败,订单号:%s err:%v", preOrder.OrderSn, err)
}
}
// 获取币安合约持仓
func getFuturesPositionNum(apiUserInfo DbModels.LineApiUser, preOrder *DbModels.LinePreOrder, tradeSet models2.TradeSet) (decimal.Decimal, error) {
futApi := FutRestApi{}
positions, err := futApi.GetPositionV3(&apiUserInfo, preOrder.Symbol)
var num decimal.Decimal
if err != nil {
logger.Errorf("handleMainReduceFilled 获取持仓信息失败,交易对:%s ,订单号:%s", preOrder.Symbol, preOrder.OrderSn)
return num, err
}
for _, item := range positions {
if item.Symbol == preOrder.Symbol {
positionAmt := utility.StrToDecimal(item.PositionAmt)
//多
if positionAmt.Cmp(decimal.Zero) > 0 && preOrder.Site == "SELL" {
num = positionAmt.Abs().Truncate(int32(tradeSet.AmountDigit))
break
} else if positionAmt.Cmp(decimal.Zero) < 0 && preOrder.Site == "BUY" {
//空
num = positionAmt.Abs().Truncate(int32(tradeSet.AmountDigit))
break
}
}
}
if num.Cmp(decimal.Zero) <= 0 {
logger.Errorf("handleMainReduceFilled 获取持仓数量为0,交易对:%s ,订单号:%s", preOrder.Symbol, preOrder.OrderSn)
return num, errors.New("获取持仓数量为0")
}
return num, nil
}
// 平仓单成交
func handleClosePosition(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
panic("unimplemented")
removeFutLossAndAddPosition(preOrder)
ids := []int{preOrder.Pid, preOrder.MainId}
//主单止盈成交
if err := db.Model(&DbModels.LinePreOrder{}).Where("id IN ?", ids).Update("status", 9).Error; err != nil {
logger.Errorf("平仓单成功 修改主单状态失败 订单号：%s:", err)
}
}
// 止损单成交
func handleStopLoss(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
// 获取主订单
order, err := GetOrderById(db, preOrder.Pid)
if err != nil {
logger.Errorf("止损单成交 获取主单失败 订单号:%s err:%v", preOrder.OrderSn, err)
return
removeFutLossAndAddPosition(preOrder)
ids := []int{preOrder.Pid, preOrder.MainId}
//主单止损成交
if err := db.Model(&DbModels.LinePreOrder{}).Where("id IN ?", ids).Update("status", 9).Error; err != nil {
logger.Errorf("止损单成功 修改主单状态失败 订单号：%s:", err)
}
// 检查订单类型
if order.OrderCategory != 1 {
if err := db.Model(&order).Where("pid =? AND order_status <9 AND order_type =0", preOrder.Pid).Error; err != nil {
logger.Errorf("对冲止损单成交 修改对冲主单状态失败 订单号:%s err:%v", order.OrderSn, err)
}
return
}
// 修改主单状态
if err := db.Model(&order).Where("id =? AND order_status < 9", preOrder.Pid).Error; err != nil {
logger.Errorf("止损单成交 修改主单状态失败 订单号:%s err:%v", order.OrderSn, err)
return
}
// 检查是否有对冲
if order.CoverType <= 0 {
return
}
triggerHedgeOrder(order, db, preOrder)
}
// 下合约对冲单
func triggerHedgeOrder(order DbModels.LinePreOrder, db *gorm.DB, preOrder *DbModels.LinePreOrder) bool {
symbolName := utility.ReplaceSuffix(order.Symbol, order.QuoteSymbol, "USDT")
// 获取交易对配置
tradeSet, err := GetTradeSet(symbolName, 1)
if tradeSet.Coin == "" || err != nil {
logger.Errorf("止损单成交 获取交易对配置失败 交易对:%s 订单号:%s err:%v", symbolName, order.OrderSn, err)
return true
}
// 检查对冲单购买金额
// if order.HedgeBuyTotal.Cmp(decimal.Zero) <= 0 {
// logger.Errorf("止损单成交 对冲单购买金额为0 订单号:%s", order.OrderSn)
// return true
// }
// 获取系统设置
setting, err := GetSystemSetting(db)
if err != nil {
logger.Errorf("止损单成交 获取系统设置失败 订单号:%s err:%v", order.OrderSn, err)
return true
}
// 获取API信息
apiInfo, err := GetChildApiInfo(order.ApiId)
if err != nil {
logger.Errorf("止损单成交 获取api信息失败 订单号:%s err:%v", order.OrderSn, err)
return true
}
// 计算价格
price := utility.StrToDecimal(preOrder.Price).Truncate(int32(tradeSet.PriceDigit))
if order.CoverType == 1 {
price = utility.StrToDecimal(tradeSet.LastPrice).Truncate(int32(tradeSet.PriceDigit))
}
if price.Cmp(decimal.Zero) <= 0 {
logger.Errorf("单价异常 price:%v 止损单编号:%s 行情:%v", price, order.OrderSn, tradeSet)
return true
}
// 创建对冲订单
hedgeOrder, hedgeStoplossOrder, hedgeTakeProfitOrder := createHedgeOrders(order, price, &tradeSet, &apiInfo, &setting)
orders := []DbModels.LinePreOrder{hedgeOrder, hedgeStoplossOrder, hedgeTakeProfitOrder}
// 批量插入订单
if err := db.Model(&DbModels.LinePreOrder{}).CreateInBatches(orders, 1).Error; err != nil {
logger.Errorf("主单止损 重下对冲失败，止损单id：%s err:%v", order.OrderSn, err)
return true
}
// 调用API下单
if err := placeFutOrder(db, hedgeOrder, price, &apiInfo); err != nil {
logger.Errorf("主单止损 重下对冲失败，止损单号：%s err:%v", order.OrderSn, err)
}
return false
}
// 创建对冲订单
func createHedgeOrders(order DbModels.LinePreOrder, price decimal.Decimal, tradeSet *models2.TradeSet, apiInfo *DbModels.LineApiUser, setting *DbModels.LineSystemSetting) (DbModels.LinePreOrder, DbModels.LinePreOrder, DbModels.LinePreOrder) {
// buyPrice := order.HedgeBuyTotal.String()
// if order.HedgeBuyType == 1 {
// mainTotal := utility.StrToDecimal(order.BuyPrice)
// buyPrice = mainTotal.Mul(order.HedgeBuyTotal).Truncate(int32(tradeSet.PriceDigit)).String()
// }
hedgeOrder := DbModels.LinePreOrder{
ApiId: apiInfo.Id,
ExchangeType: order.ExchangeType,
Pid: order.Pid,
Symbol: order.Symbol,
SymbolType: global.SYMBOL_FUTURES,
SignPrice: order.Price,
SignPriceType: "new",
Rate: "0",
// BuyPrice: buyPrice,
OrderCategory: 2,
OrderSn: utility.Int64ToString(snowflakehelper.GetOrderId()),
OrderType: 0,
CoverType: 0,
// MainOrderType: order.HedgeOrderType,
}
hedgeStoplossOrder := order
hedgeTakeProfitOrder := order
if order.Site == "BUY" {
hedgeOrder.Site = "SELL"
hedgeStoplossOrder.Site = "BUY"
hedgeTakeProfitOrder.Site = "BUY"
} else {
hedgeOrder.Site = "BUY"
hedgeStoplossOrder.Site = "SELL"
hedgeTakeProfitOrder.Site = "SELL"
}
// 计算止盈止损价格
// if hedgeOrder.Site == "BUY" {
// hedgeTakeProfitOrder.Price = price.Mul(decimal.NewFromInt(1).Add(order.HedgeTakeProfit.Div(decimal.NewFromInt(100)))).Truncate(int32(tradeSet.PriceDigit)).String()
// hedgeStoplossOrder.Price = price.Mul(decimal.NewFromInt(1).Sub(order.HedgeStopLoss.Div(decimal.NewFromInt(100)))).Truncate(int32(tradeSet.PriceDigit)).String()
// } else {
// hedgeTakeProfitOrder.Price = price.Mul(decimal.NewFromInt(1).Sub(order.HedgeTakeProfit.Div(decimal.NewFromInt(100)))).Truncate(int32(tradeSet.PriceDigit)).String()
// hedgeStoplossOrder.Price = price.Mul(decimal.NewFromInt(1).Add(order.HedgeStopLoss.Div(decimal.NewFromInt(100)))).Truncate(int32(tradeSet.PriceDigit)).String()
// }
if hedgeOrder.MainOrderType == "LIMIT" {
coverRate := utility.StrToDecimal(setting.CoverOrderTypeBRate)
price = price.Mul(decimal.NewFromInt(1).Add(coverRate)).Truncate(int32(tradeSet.PriceDigit))
}
// num := order.HedgeBuyTotal.Div(price).Truncate(int32(tradeSet.AmountDigit))
hedgeOrder.Price = price.String()
// hedgeOrder.Num = num.String()
hedgeStoplossOrder.OrderSn = utility.Int64ToString(snowflakehelper.GetOrderId())
// hedgeStoplossOrder.Rate = order.HedgeStopLoss.String()
// hedgeStoplossOrder.Num = num.String()
hedgeTakeProfitOrder.OrderSn = utility.Int64ToString(snowflakehelper.GetOrderId())
// hedgeTakeProfitOrder.Rate = order.HedgeTakeProfit.String()
// hedgeTakeProfitOrder.Num = num.String()
return hedgeOrder, hedgeStoplossOrder, hedgeTakeProfitOrder
}
// 调用合约API下单
func placeFutOrder(db *gorm.DB, hedgeOrder DbModels.LinePreOrder, price decimal.Decimal, apiInfo *DbModels.LineApiUser) error {
futApi := FutRestApi{}
params := FutOrderPlace{
ApiId: apiInfo.Id,
Symbol: hedgeOrder.Symbol,
Side: hedgeOrder.Site,
Quantity: utility.StrToDecimal(hedgeOrder.Num),
Price: price,
NewClientOrderId: hedgeOrder.OrderSn,
SideType: hedgeOrder.MainOrderType,
OrderType: hedgeOrder.MainOrderType,
}
return futApi.OrderPlace(db, params)
}
// 止盈单成交
func handleTakeProfit(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
if preOrder.OrderCategory == 1 {
//主单止盈成交
if err := db.Model(&DbModels.LinePreOrder{}).Where("id = ?", preOrder.Pid).Update("order_type", 3).Error; err != nil {
logger.Errorf("主单止盈成功修改主单状态失败 订单号：%s:", err)
removeFutLossAndAddPosition(preOrder)
ids := []int{preOrder.Pid, preOrder.MainId}
//主单止盈成交
if err := db.Model(&DbModels.LinePreOrder{}).Where("id IN ?", ids).Update("status", 9).Error; err != nil {
logger.Errorf("主单止盈成功修改主单状态失败 订单号：%s:", err)
}
}
// 清除合约缓存
func removeFutLossAndAddPosition(preOrder *DbModels.LinePreOrder) {
stoplossKey := fmt.Sprintf(rediskey.FuturesStopLossList, global.EXCHANGE_BINANCE)
stoplossVal, _ := helper.DefaultRedis.GetAllList(stoplossKey)
addPositionKey := fmt.Sprintf(rediskey.FuturesAddPositionList, global.EXCHANGE_BINANCE)
addPositionVal, _ := helper.DefaultRedis.GetAllList(addPositionKey)
reduceKey := fmt.Sprintf(rediskey.FuturesReduceList, global.EXCHANGE_BINANCE)
reduceVal, _ := helper.DefaultRedis.GetAllList(reduceKey)
stoploss := dto.StopLossRedisList{}
addPosition := AddPositionList{}
reduce := ReduceListItem{}
//止损缓存
for _, v := range stoplossVal {
sonic.Unmarshal([]byte(v), &stoploss)
if stoploss.MainId == preOrder.MainId {
_, err := helper.DefaultRedis.LRem(stoplossKey, v)
if err != nil {
logger.Errorf("订单回调失败, 回调订单号：%s 删除止损缓存失败:%v", preOrder.OrderSn, err)
}
}
} else {
//对冲单止盈成交
if err := db.Model(&DbModels.LinePreOrder{}).Where("pid = ? AND order_category = 2 AND order_type =0 AND status < 9", preOrder.Pid).Update("status", 9).Error; err != nil {
logger.Errorf("对冲止盈成功修改主单状态失败 订单号：%s:", err)
}
//加仓缓存
for _, v := range addPositionVal {
sonic.Unmarshal([]byte(v), &addPosition)
if addPosition.MainId == preOrder.MainId {
_, err := helper.DefaultRedis.LRem(addPositionKey, v)
if err != nil {
logger.Errorf("订单回调失败, 回调订单号：%s 删除加仓缓存失败:%v", preOrder.OrderSn, err)
}
}
}
//减仓缓存
for _, v := range reduceVal {
sonic.Unmarshal([]byte(v), &reduce)
if reduce.MainId == preOrder.MainId {
_, err := helper.DefaultRedis.LRem(reduceKey, v)
if err != nil {
logger.Errorf("订单回调失败, 回调订单号：%s 删除减仓缓存失败:%v", preOrder.OrderSn, err)
}
}
}
}
@ -479,13 +368,6 @@ func handleTakeProfit(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
// preOrder 主单
func handleFutMainOrderFilled(db *gorm.DB, preOrder *models.LinePreOrder) {
orders := []models.LinePreOrder{}
if err := db.Model(&DbModels.LinePreOrder{}).Where("pid = ? AND order_type > 0 AND status = '0' ", preOrder.Id).Find(&orders).Error; err != nil {
logger.Error("订单回调查询止盈止损单失败:", err)
return
}
futApi := FutRestApi{}
num, _ := decimal.NewFromString(preOrder.Num)
tradeSet, _ := GetTradeSet(preOrder.Symbol, 0)
if tradeSet.Coin == "" {
@ -493,6 +375,21 @@ func handleFutMainOrderFilled(db *gorm.DB, preOrder *models.LinePreOrder) {
return
}
if err := db.Model(&DbModels.LinePreOrder{}).
Where("pid = ? AND order_type > 0 AND status = '0' ", preOrder.Id).
Find(&orders).Error; err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
logger.Error("订单回调查询止盈止损单失败:", err)
return
} else if len(orders) == 0 && preOrder.OrderCategory == 3 {
orders, err = makeFuturesTakeAndReduce(preOrder, db, tradeSet, orders)
if err != nil {
return
}
}
futApi := FutRestApi{}
num, _ := decimal.NewFromString(preOrder.Num)
for i, order := range orders {
if i >= 2 { // 最多处理 2 个订单
break
@ -511,14 +408,122 @@ func handleFutMainOrderFilled(db *gorm.DB, preOrder *models.LinePreOrder) {
case 2: // 止损
processFutStopLossOrder(db, order, price, num)
case 4: //减仓
processFutReduceOrder(db, order, price, num)
processFutReduceOrder(order, price, num)
}
}
}
// 构建合约止盈、减仓单
func makeFuturesTakeAndReduce(preOrder *DbModels.LinePreOrder, db *gorm.DB, tradeSet models2.TradeSet, orders []DbModels.LinePreOrder) ([]DbModels.LinePreOrder, error) {
ext := models.LinePreOrderExt{}
apiInfo, err := GetApiInfo(preOrder.ApiId)
price := utility.StrToDecimal(preOrder.Price)
if apiInfo.Id == 0 {
logger.Error("订单回调查询apiuserinfo失败 err:", err)
return nil, errors.New("订单回调查询apiuserinfo失败")
}
if err := db.Model(&ext).Where("order_id = ?", preOrder.Id).First(&ext).Error; err != nil {
logger.Error("订单回调查询止盈止损单扩展表失败:", err)
return nil, errors.New("订单回调查询止盈止损单扩展表失败")
}
totalLossAmountU, _ := GetTotalLossAmount(db, preOrder.MainId)
num, err := getFuturesPositionNum(apiInfo, preOrder, tradeSet)
if err != nil {
logger.Error("订单回调查询持仓数量失败:", err)
return nil, errors.New("订单回调查询持仓数量失败")
}
//止盈单
if ext.TakeProfitRatio.Cmp(decimal.Zero) > 0 {
profitOrder := models.LinePreOrder{}
copier.Copy(&profitOrder, preOrder)
var rate decimal.Decimal
profitOrder.OrderSn = strconv.FormatInt(snowflakehelper.GetOrderId(), 10)
profitOrder.Pid = preOrder.Id
profitOrder.OrderType = 1
profitOrder.Status = 0
profitOrder.MainId = ext.MainOrderId
profitOrder.Num = num.String()
//止盈需要累加之前的亏损
if totalLossAmountU.Cmp(decimal.Zero) > 0 {
rate = totalLossAmountU.Div(num).Div(price).Sub(decimal.NewFromInt(1)).Abs().Add(ext.TakeProfitRatio).Truncate(2)
} else {
rate = ext.TakeProfitRatio
}
profitOrder.Rate = rate.String()
orders = append(orders, profitOrder)
}
//减仓单
if ext.ReducePriceRatio.Cmp(decimal.Zero) > 0 {
stopOrder := models.LinePreOrder{}
copier.Copy(&stopOrder, preOrder)
stopOrder.OrderSn = strconv.FormatInt(snowflakehelper.GetOrderId(), 10)
stopOrder.Pid = preOrder.Id
stopOrder.MainId = ext.MainOrderId
stopOrder.OrderType = 4
stopOrder.Status = 0
stopOrder.Rate = ext.ReducePriceRatio.String()
stopOrder.Num = num.String()
orders = append(orders, stopOrder)
}
for index := range orders {
orderRate := utility.StrToDecimal(orders[index].Rate)
if strings.ToUpper(preOrder.Site) == "BUY" {
orders[index].Site = "SELL"
orders[index].Price = utility.StrToDecimal(preOrder.Price).Mul(decimal.NewFromInt(1).Sub(orderRate.Div(decimal.NewFromInt(100)))).Truncate(int32(tradeSet.PriceDigit)).String()
} else {
orders[index].Site = "BUY"
orders[index].Price = utility.StrToDecimal(preOrder.Price).Mul(decimal.NewFromInt(1).Add(orderRate.Div(decimal.NewFromInt(100)))).Truncate(int32(tradeSet.PriceDigit)).String()
}
}
if len(orders) > 0 {
if err := db.Create(&orders).Error; err != nil {
logger.Error("主单回调，创建止盈、减仓单失败")
return orders, errors.New("主单回调，创建止盈、减仓单失败")
}
}
return orders, nil
}
// 减仓单
func processFutReduceOrder(db *gorm.DB, order DbModels.LinePreOrder, price, num decimal.Decimal) {
// key := fmt.Sprintf(rediskey.SpotReduceList, global.EXCHANGE_BINANCE)
func processFutReduceOrder(order DbModels.LinePreOrder, price, num decimal.Decimal) {
key := fmt.Sprintf(rediskey.FuturesReduceList, global.EXCHANGE_BINANCE)
item := ReduceListItem{
Id: order.Id,
ApiId: order.ApiId,
Pid: order.Pid,
MainId: order.MainId,
Price: price,
Num: num,
Side: order.Site,
Symbol: order.Symbol,
OrderSn: order.OrderSn,
}
itemVal, err := sonic.MarshalString(&item)
if err != nil {
logger.Errorf("序列化失败 err:%v", err)
return
}
if err := helper.DefaultRedis.RPushList(key, itemVal); err != nil {
logger.Errorf("减仓单写入缓存失败 err:%v", err)
return
}
}
// 处理止盈订单