691 lines
21 KiB
Go
691 lines
21 KiB
Go
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"
|
|
|
|
"github.com/bytedance/sonic"
|
|
"github.com/go-admin-team/go-admin-core/logger"
|
|
"github.com/jinzhu/copier"
|
|
"github.com/shopspring/decimal"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
/*
|
|
修改订单信息
|
|
*/
|
|
func ChangeFutureOrder(mapData map[string]interface{}) {
|
|
// 检查订单号是否存在
|
|
orderSn, ok := mapData["c"]
|
|
originOrderSn := mapData["C"] //取消操作 代表原始订单号
|
|
|
|
if !ok {
|
|
logger.Error("合约订单回调失败,没有订单号")
|
|
return
|
|
}
|
|
|
|
if originOrderSn != nil && originOrderSn != "" {
|
|
orderSn = originOrderSn
|
|
}
|
|
|
|
// 获取数据库连接
|
|
db := GetDBConnection()
|
|
if db == nil {
|
|
logger.Error("合约订单回调失败,无法获取数据库连接")
|
|
return
|
|
}
|
|
|
|
// 获取 Redis 锁
|
|
lock := helper.NewRedisLock(fmt.Sprintf(rediskey.FutCallBack, orderSn), 10, 5, 500*time.Millisecond)
|
|
acquired, err := lock.AcquireWait(context.Background())
|
|
if err != nil {
|
|
logger.Error("合约订单回调失败,获取锁失败:", orderSn, " err:", err)
|
|
return
|
|
}
|
|
if !acquired {
|
|
logger.Error("合约订单回调失败,获取锁失败:", orderSn)
|
|
return
|
|
}
|
|
defer lock.Release()
|
|
|
|
// 查询订单
|
|
preOrder, err := getPreOrder(db, orderSn)
|
|
if err != nil {
|
|
logger.Error("合约订单回调失败,查询订单失败:", orderSn, " err:", err)
|
|
return
|
|
}
|
|
|
|
// 解析订单状态
|
|
status, ok := mapData["X"].(string)
|
|
if !ok {
|
|
mapStr, _ := sonic.Marshal(&mapData)
|
|
logger.Error("订单回调失败,没有状态:", string(mapStr))
|
|
return
|
|
}
|
|
// 更新订单状态
|
|
orderStatus, reason := parseOrderStatus(status, mapData)
|
|
|
|
if orderStatus == 0 {
|
|
logger.Error("订单回调失败,状态错误:", orderSn, " status:", status, " reason:", reason)
|
|
return
|
|
}
|
|
|
|
if err := updateOrderStatus(db, preOrder, orderStatus, reason, true, mapData); err != nil {
|
|
logger.Error("修改订单状态失败:", orderSn, " err:", err)
|
|
return
|
|
}
|
|
|
|
handleFutOrderByType(db, preOrder, orderStatus)
|
|
}
|
|
|
|
// 合约回调
|
|
func handleFutOrderByType(db *gorm.DB, preOrder *DbModels.LinePreOrder, orderStatus int) {
|
|
switch {
|
|
//主单成交
|
|
case preOrder.OrderType == 0 && orderStatus == 6:
|
|
handleFutMainOrderFilled(db, preOrder)
|
|
//止盈成交
|
|
case preOrder.OrderType == 1 && orderStatus == 6:
|
|
handleTakeProfit(db, preOrder)
|
|
//减仓回调
|
|
case preOrder.OrderType == 4 && orderStatus == 6:
|
|
handleReduceFilled(db, preOrder)
|
|
//止损成交
|
|
case preOrder.OrderType == 2 && orderStatus == 6:
|
|
handleStopLoss(db, preOrder)
|
|
//平仓成交
|
|
case preOrder.OrderType == 3 && orderStatus == 6:
|
|
handleClosePosition(db, preOrder)
|
|
}
|
|
}
|
|
|
|
// 减仓回调
|
|
func handleReduceFilled(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
|
|
apiUserInfo, _ := GetApiInfo(preOrder.ApiId)
|
|
|
|
if apiUserInfo.Id == 0 {
|
|
logger.Errorf("handleMainReduceFilled 获取api信息失败,订单号:%s", preOrder.OrderSn)
|
|
return
|
|
}
|
|
|
|
tradeSet, err := GetTradeSet(preOrder.Symbol, 1)
|
|
|
|
if err != nil {
|
|
logger.Errorf("handleMainReduceFilled 获取交易对设置失败,订单号:%s", preOrder.OrderSn)
|
|
return
|
|
}
|
|
|
|
price := utility.StrToDecimal(preOrder.Price)
|
|
parentOrder, err := GetOrderById(db, preOrder.Pid)
|
|
|
|
if err != nil {
|
|
logger.Errorf("handleMainReduceFilled 获取主单失败,订单号:%s", preOrder.OrderSn)
|
|
return
|
|
}
|
|
parentPrice := utility.StrToDecimal(parentOrder.Price)
|
|
num := utility.StrToDecimal(preOrder.Num)
|
|
lossAmount := price.Sub(parentPrice).Abs().Mul(num)
|
|
|
|
if !strings.HasSuffix(preOrder.Symbol, "USDT") {
|
|
tradeSetU, err := GetTradeSet(utility.ReplaceSuffix(preOrder.Symbol, preOrder.QuoteSymbol, ""), 1)
|
|
|
|
if err != nil {
|
|
logger.Errorf("handleMainReduceFilled 获取币本位对应U交易对设置失败,订单号:%s", preOrder.OrderSn)
|
|
return
|
|
}
|
|
|
|
lossAmount = lossAmount.Mul(utility.StrToDecimal(tradeSetU.LastPrice)).Truncate(2)
|
|
}
|
|
|
|
if err := db.Model(&parentOrder).Where("loss_amount=0", preOrder.Pid).Update("loss_amount", lossAmount).Error; err != nil {
|
|
logger.Errorf("handleMainReduceFilled 更新亏损金额失败,订单号:%s", preOrder.OrderSn)
|
|
return
|
|
}
|
|
|
|
orders := make([]models.LinePreOrder, 0)
|
|
rate := utility.StringAsFloat(preOrder.Rate)
|
|
ext := models.LinePreOrderExt{}
|
|
//获取订单配置
|
|
db.Model(&ext).Where("order_id =?", preOrder.Pid).First(&ext)
|
|
|
|
// 不是100%减仓 就需要挂止盈止损
|
|
if rate < 100 {
|
|
totalNum, err := getFuturesPositionNum(apiUserInfo, preOrder, tradeSet)
|
|
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
takeProfitOrder := models.LinePreOrder{}
|
|
copier.Copy(&takeProfitOrder, &preOrder)
|
|
takeProfitOrder.Id = 0
|
|
takeProfitOrder.OrderSn = utility.Int64ToString(snowflakehelper.GetOrderId())
|
|
takeProfitOrder.Status = 0
|
|
takeProfitOrder.Price = price.Mul(decimal.NewFromInt(1).Add(ext.TakeProfitRatio)).Truncate(int32(tradeSet.PriceDigit)).String()
|
|
takeProfitOrder.OrderType = 1
|
|
takeProfitOrder.Rate = "100"
|
|
takeProfitOrder.SignPrice = preOrder.Price
|
|
takeProfitOrder.CreatedAt = time.Now()
|
|
takeProfitOrder.BuyPrice = "0"
|
|
takeProfitOrder.MainOrderType = "LIMIT"
|
|
takeProfitOrder.Num = totalNum.String()
|
|
orders = append(orders, takeProfitOrder)
|
|
|
|
//有止损单
|
|
if ext.ReduceStopLossRatio.Cmp(decimal.Zero) > 0 {
|
|
var stoploss models.LinePreOrder
|
|
|
|
copier.Copy(&stoploss, &preOrder)
|
|
stoploss.Id = 0
|
|
stoploss.OrderSn = utility.Int64ToString(snowflakehelper.GetOrderId())
|
|
stoploss.Status = 0
|
|
stoploss.CreatedAt = time.Now()
|
|
stoploss.OrderType = 2
|
|
stoploss.SignPrice = preOrder.Price
|
|
stoploss.BuyPrice = "0"
|
|
stoploss.Rate = "100"
|
|
stoploss.MainOrderType = "LIMIT"
|
|
stoploss.Num = totalNum.String()
|
|
|
|
orders = append(orders, stoploss)
|
|
}
|
|
|
|
if err := db.Create(&orders).Error; err != nil {
|
|
logger.Errorf("handleMainReduceFilled 创建止盈止损单失败:%v", err)
|
|
return
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|
|
}
|
|
|
|
//加仓待触发
|
|
addPositionOrder := DbModels.LinePreOrder{}
|
|
|
|
if err := db.Model(&addPositionOrder).Where("main_id =? AND order_category=3 AND status=0", preOrder.MainId).First(addPositionOrder).Error; err != nil {
|
|
logger.Errorf("handleMainReduceFilled 获取加仓单失败,订单号:%s err:%v", preOrder.OrderSn, err)
|
|
return
|
|
}
|
|
|
|
keyFutAddpositionKey := fmt.Sprintf(rediskey.FuturesAddPositionList, global.EXCHANGE_BINANCE)
|
|
|
|
addPositionData := AddPositionList{
|
|
MainId: addPositionOrder.MainId,
|
|
Pid: addPositionOrder.Pid,
|
|
Price: utility.StrToDecimal(addPositionOrder.Price),
|
|
ApiId: addPositionOrder.ApiId,
|
|
Symbol: addPositionOrder.Symbol,
|
|
Side: addPositionOrder.Site,
|
|
SymbolType: addPositionOrder.SymbolType,
|
|
}
|
|
|
|
addVal, err := sonic.MarshalString(addPositionData)
|
|
|
|
if err != nil {
|
|
logger.Errorf("handleMainReduceFilled 序列化加仓单失败,订单号:%s err:%v", preOrder.OrderSn, err)
|
|
return
|
|
}
|
|
|
|
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) {
|
|
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) {
|
|
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 handleTakeProfit(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
|
|
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)
|
|
}
|
|
}
|
|
}
|
|
|
|
//加仓缓存
|
|
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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 主单成交 处理止盈止损订单
|
|
// preOrder 主单
|
|
func handleFutMainOrderFilled(db *gorm.DB, preOrder *models.LinePreOrder) {
|
|
orders := []models.LinePreOrder{}
|
|
tradeSet, _ := GetTradeSet(preOrder.Symbol, 0)
|
|
|
|
if tradeSet.Coin == "" {
|
|
logger.Error("获取交易对失败")
|
|
return
|
|
}
|
|
|
|
if tradeSet.Coin == "" {
|
|
logger.Errorf("获取交易对配置失败, 回调订单号：%s", preOrder.OrderSn)
|
|
return
|
|
}
|
|
|
|
//预生成加仓单
|
|
shouldReturn := createFutPreAddPosition(preOrder, db, tradeSet)
|
|
if shouldReturn {
|
|
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
|
|
}
|
|
price := utility.StrToDecimal(order.Price).Truncate(int32(tradeSet.PriceDigit))
|
|
num = num.Truncate(int32(tradeSet.AmountDigit))
|
|
order.Price = price.String()
|
|
|
|
if err := db.Model(&order).Update("num", num).Error; err != nil {
|
|
logger.Errorf("修改止盈止损数量失败 订单号:%s err:%v", order.OrderSn, err)
|
|
}
|
|
|
|
switch order.OrderType {
|
|
case 1: // 止盈
|
|
processFutTakeProfitOrder(db, futApi, order, num)
|
|
case 2: // 止损
|
|
processFutStopLossOrder(db, order, price, num)
|
|
case 4: //减仓
|
|
processFutReduceOrder(order, price, num)
|
|
}
|
|
}
|
|
}
|
|
|
|
// 生成加仓单
|
|
func createFutPreAddPosition(preOrder *DbModels.LinePreOrder, db *gorm.DB, tradeSet models2.TradeSet) bool {
|
|
//主单类型
|
|
if preOrder.OrderCategory == 1 {
|
|
orderExts, err := GetOrderExts(db, preOrder.Id)
|
|
|
|
if err != nil {
|
|
logger.Errorf("预生成加仓单失败, 回调订单号：%s 获取主单拓展配置失败:%v", preOrder.OrderSn, err)
|
|
return true
|
|
}
|
|
|
|
price := utility.StrToDecimal(preOrder.Price)
|
|
for _, v := range orderExts {
|
|
if v.OrderId == 0 {
|
|
var data DbModels.LinePreOrder
|
|
|
|
copier.Copy(&data, &v)
|
|
|
|
data.Id = 0
|
|
data.Pid = preOrder.Id
|
|
data.OrderSn = utility.Int64ToString(snowflakehelper.GetOrderId())
|
|
data.MainId = preOrder.Id
|
|
data.CreatedAt = time.Now()
|
|
data.MainOrderType = v.AddPositionOrderType
|
|
data.Status = 0
|
|
data.OrderCategory = 3
|
|
var percentage decimal.Decimal
|
|
|
|
if data.Site == "BUY" {
|
|
percentage = decimal.NewFromInt(1).Add(v.AddPositionPriceRatio.Div(decimal.NewFromInt(100)))
|
|
} else {
|
|
percentage = decimal.NewFromInt(1).Sub(v.AddPositionPriceRatio.Div(decimal.NewFromInt(100)))
|
|
}
|
|
data.Price = price.Mul(percentage).Truncate(int32(tradeSet.PriceDigit)).String()
|
|
|
|
err := db.Transaction(func(tx *gorm.DB) error {
|
|
if err2 := tx.Create(&data).Error; err2 != nil {
|
|
return err2
|
|
}
|
|
|
|
v.OrderId = data.Id
|
|
if err2 := tx.Model(&v).Update("order_id", data.Id).Error; err2 != nil {
|
|
return err2
|
|
}
|
|
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
logger.Errorf("预生成加仓单失败, 回调订单号：%s 预生成加仓单失败:%v", preOrder.OrderSn, err)
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
// 构建合约止盈、减仓单
|
|
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()
|
|
|
|
if ext.ReduceNumRatio.Cmp(decimal.Zero) > 0 {
|
|
stopOrder.Num = num.Mul(ext.ReduceNumRatio.Div(decimal.NewFromInt(100))).Truncate(int32(tradeSet.AmountDigit)).String()
|
|
} else {
|
|
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(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
|
|
}
|
|
}
|
|
|
|
// 处理止盈订单
|
|
func processFutTakeProfitOrder(db *gorm.DB, futApi FutRestApi, order models.LinePreOrder, num decimal.Decimal) {
|
|
price, _ := decimal.NewFromString(order.Price)
|
|
|
|
params := FutOrderPlace{
|
|
ApiId: order.ApiId,
|
|
Symbol: order.Symbol,
|
|
Side: order.Site,
|
|
Price: price,
|
|
Quantity: num,
|
|
OrderType: "TAKE_PROFIT",
|
|
StopPrice: price,
|
|
NewClientOrderId: order.OrderSn,
|
|
}
|
|
|
|
err := futApi.OrderPlace(db, params)
|
|
|
|
if err != nil {
|
|
for x := 0; x < 5; x++ {
|
|
if strings.Contains(err.Error(), "LOT_SIZE") {
|
|
break
|
|
}
|
|
|
|
err = futApi.OrderPlace(db, params)
|
|
|
|
if err == nil {
|
|
break
|
|
}
|
|
|
|
time.Sleep(time.Millisecond * 250)
|
|
}
|
|
}
|
|
|
|
if err != nil {
|
|
logger.Error("合约止盈下单失败:", order.OrderSn, " err:", err)
|
|
if err := db.Model(&DbModels.LinePreOrder{}).Where("id = ?", order.Id).
|
|
Updates(map[string]interface{}{"status": "2", "desc": err.Error(), "num": params.Quantity}).Error; err != nil {
|
|
logger.Error("合约止盈下单失败,更新状态失败:", order.OrderSn, " err:", err)
|
|
}
|
|
} else {
|
|
if err := db.Model(&DbModels.LinePreOrder{}).Where("id = ? and status =0", order.Id).
|
|
Updates(map[string]interface{}{"status": "1", "num": num.String()}).Error; err != nil {
|
|
logger.Error("合约止盈下单成功,更新状态失败:", order.OrderSn, " err:", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// 处理止损订单
|
|
// order 止损单
|
|
func processFutStopLossOrder(db *gorm.DB, order models.LinePreOrder, price, num decimal.Decimal) error {
|
|
params := FutOrderPlace{
|
|
ApiId: order.ApiId,
|
|
Symbol: order.Symbol,
|
|
Side: order.Site,
|
|
Price: price,
|
|
Quantity: num,
|
|
OrderType: "STOP",
|
|
StopPrice: price,
|
|
NewClientOrderId: order.OrderSn,
|
|
}
|
|
futApi := FutRestApi{}
|
|
var err error
|
|
|
|
for x := 1; x < 4; x++ {
|
|
err = futApi.OrderPlace(db, params)
|
|
|
|
if err == nil {
|
|
break
|
|
}
|
|
|
|
time.Sleep(time.Millisecond * 200)
|
|
}
|
|
|
|
if err != nil {
|
|
if err2 := db.Model(&order).Updates(map[string]interface{}{"status": 2, "desc": err.Error()}).Error; err2 != nil {
|
|
logger.Error("合约止损下单失败,更新状态失败:", order.OrderSn, " err:", err2)
|
|
}
|
|
} else {
|
|
if err := db.Model(&order).Where("status =0").
|
|
Updates(map[string]interface{}{"status": "1"}).Error; err != nil {
|
|
logger.Error("合约止损下单成功,更新状态失败:", order.OrderSn, " err:", err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|