1075 lines
34 KiB
Go
1075 lines
34 KiB
Go
package binanceservice
|
||
|
||
import (
|
||
"database/sql"
|
||
"errors"
|
||
"fmt"
|
||
DbModels "go-admin/app/admin/models"
|
||
"go-admin/common/global"
|
||
"go-admin/common/helper"
|
||
"go-admin/models"
|
||
"go-admin/pkg/maphelper"
|
||
"go-admin/pkg/utility/snowflakehelper"
|
||
"go-admin/services/cacheservice"
|
||
"strconv"
|
||
"time"
|
||
|
||
"github.com/go-admin-team/go-admin-core/logger"
|
||
"github.com/go-admin-team/go-admin-core/sdk/service"
|
||
"github.com/shopspring/decimal"
|
||
"gorm.io/gorm"
|
||
)
|
||
|
||
type ReverseService struct {
|
||
service.Service
|
||
}
|
||
|
||
// SaveMainOrder 保存订单信息
|
||
// mapData: 下单数据
|
||
// status: 订单状态
|
||
// orderSn: 自定义订单号
|
||
func (e *ReverseService) handleSimpleStatusChange(status string, orderSn string, mapData map[string]interface{}) (bool, error) {
|
||
statusMap := map[string]int{
|
||
"NEW": 2,
|
||
"CANCELED": 6,
|
||
"EXPIRED": 7,
|
||
"EXPIRED_IN_MATCH": 7,
|
||
}
|
||
if newStatus, ok := statusMap[status]; ok {
|
||
_ = e.changeOrderStatus(newStatus, orderSn, mapData)
|
||
return false, nil
|
||
}
|
||
return false, fmt.Errorf("不支持的订单状态 %s", status)
|
||
}
|
||
|
||
// ReverseOrder 反向下单
|
||
// apiKey: api key
|
||
// mapData: 下单数据
|
||
// return apiInfo, bool
|
||
// bool: true=需要反单, false=不需要反单
|
||
func (e *ReverseService) ReverseOrder(apiKey string, mapData map[string]interface{}) (bool, error) {
|
||
apiInfo := GetApiInfoByKey(apiKey)
|
||
|
||
if apiInfo.Id == 0 {
|
||
e.Log.Errorf("获取apiInfo失败 %s", apiKey)
|
||
return false, nil
|
||
}
|
||
|
||
status, _ := maphelper.GetString(mapData, "X")
|
||
orderSn, err := maphelper.GetString(mapData, "c")
|
||
if err != nil {
|
||
return true, err
|
||
}
|
||
ot, err := maphelper.GetString(mapData, "ot")
|
||
|
||
if err != nil {
|
||
return true, err
|
||
}
|
||
|
||
switch status {
|
||
case "NEW", "CANCELED", "EXPIRED", "EXPIRED_IN_MATCH":
|
||
result, err := e.handleSimpleStatusChange(status, orderSn, mapData)
|
||
|
||
//如果是 新开止盈止损 需要取消反单的止盈止损之后重下反单止盈止损
|
||
if status == "NEW" && (ot == "TAKE_PROFIT_MARKET" || ot == "STOP_MARKET" || ot == "TAKE_PROFIT" || ot == "STOP") &&
|
||
apiInfo.ReverseStatus == 1 && apiInfo.OpenStatus == 1 && apiInfo.ReverseApiId > 0 {
|
||
symbolCode, err := maphelper.GetString(mapData, "s")
|
||
|
||
if err != nil {
|
||
e.Log.Errorf("获取symbolCode失败 symbol:%s err:%v", symbolCode, err)
|
||
return true, err
|
||
}
|
||
|
||
symbol, err := cacheservice.GetTradeSet(global.EXCHANGE_BINANCE, symbolCode, 1)
|
||
|
||
if err != nil {
|
||
e.Log.Errorf("获取symbol失败 symbol:%s err:%v", symbolCode, err)
|
||
return true, err
|
||
}
|
||
|
||
if err := e.ReTakeOrStopOrder(&mapData, orderSn, &apiInfo, &symbol); err != nil {
|
||
return true, err
|
||
}
|
||
}
|
||
|
||
return result, err
|
||
case "FILLED":
|
||
if apiInfo.ReverseStatus == 1 && apiInfo.OpenStatus == 1 && apiInfo.ReverseApiId > 0 {
|
||
reverseApiInfo, err := GetApiInfo(apiInfo.ReverseApiId)
|
||
if err != nil {
|
||
e.Log.Errorf("获取反向api信息失败 reverseApiId:%d, err:%v", apiInfo.ReverseApiId, err)
|
||
return true, err
|
||
}
|
||
|
||
mainOrder, err := e.SaveMainOrder(mapData, apiInfo)
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
|
||
switch {
|
||
case mainOrder.PositionSide == "LONG" && mainOrder.Side == "BUY", mainOrder.PositionSide == "SHORT" && mainOrder.Side == "SELL":
|
||
if mainOrder.Category == 0 {
|
||
needReverseOrder, closePosition, err1 := e.savePosition(&mainOrder, &apiInfo, true, false)
|
||
|
||
if err1 != nil {
|
||
return true, err1
|
||
}
|
||
|
||
if needReverseOrder {
|
||
e.DoAddReverseOrder(&mainOrder, &reverseApiInfo, apiInfo.OrderProportion, false, closePosition)
|
||
}
|
||
}
|
||
case mainOrder.PositionSide == "SHORT" && mainOrder.Side == "BUY", mainOrder.PositionSide == "LONG" && mainOrder.Side == "SELL":
|
||
if mainOrder.Category == 0 {
|
||
needReverseOrder, closePosition, err1 := e.savePosition(&mainOrder, &apiInfo, true, true)
|
||
|
||
if err1 != nil {
|
||
e.Log.Errorf("保存主订单失败: %v", err1)
|
||
return true, err1
|
||
}
|
||
|
||
if needReverseOrder {
|
||
e.DoAddReverseOrder(&mainOrder, &reverseApiInfo, apiInfo.OrderProportion, true, closePosition)
|
||
}
|
||
}
|
||
default:
|
||
return true, errors.New("不支持的订单类型")
|
||
}
|
||
return true, nil
|
||
} else if apiInfo.Subordinate == "2" {
|
||
e.changeOrderStatus(3, orderSn, mapData)
|
||
|
||
symbol, err := maphelper.GetString(mapData, "s")
|
||
|
||
if err != nil {
|
||
return true, err
|
||
}
|
||
positionSide, err := maphelper.GetString(mapData, "ps")
|
||
|
||
if err != nil {
|
||
return true, err
|
||
}
|
||
side, err := maphelper.GetString(mapData, "S")
|
||
if err != nil {
|
||
return true, err
|
||
}
|
||
|
||
price := maphelper.GetDecimal(mapData, "ap")
|
||
totalNum := maphelper.GetDecimal(mapData, "z")
|
||
|
||
mainOrder := DbModels.LineReverseOrder{
|
||
ApiId: apiInfo.Id,
|
||
Symbol: symbol,
|
||
PositionSide: positionSide,
|
||
TotalNum: totalNum,
|
||
Side: side,
|
||
Price: price,
|
||
FinalPrice: price,
|
||
}
|
||
|
||
switch {
|
||
case mainOrder.PositionSide == "LONG" && mainOrder.Side == "BUY", mainOrder.PositionSide == "SHORT" && mainOrder.Side == "SELL":
|
||
if mainOrder.Category == 0 {
|
||
if _, _, err1 := e.savePositionWithRetry(&mainOrder, &apiInfo, false, false); err1 != nil {
|
||
e.Log.Errorf("反向订单持仓保存失败: %v", err1)
|
||
return true, err1
|
||
}
|
||
}
|
||
case mainOrder.PositionSide == "SHORT" && mainOrder.Side == "BUY", mainOrder.PositionSide == "LONG" && mainOrder.Side == "SELL":
|
||
if mainOrder.Category == 0 {
|
||
if _, _, err1 := e.savePositionWithRetry(&mainOrder, &apiInfo, false, true); err1 != nil {
|
||
e.Log.Errorf("反向订单持仓保存失败: %v", err1)
|
||
return true, err1
|
||
}
|
||
}
|
||
default:
|
||
return true, errors.New("不支持的订单类型")
|
||
}
|
||
}
|
||
default:
|
||
return false, fmt.Errorf("不支持的订单状态 %s", status)
|
||
}
|
||
|
||
return false, nil
|
||
}
|
||
|
||
// 修改订单状态
|
||
// status: 订单状态 1-待下单 2-已下单 3-已成交 6-已取消 7-已过期
|
||
func (e *ReverseService) changeOrderStatus(status int, orderSn string, mapData map[string]interface{}) error {
|
||
data := map[string]interface{}{"status": status, "updated_at": time.Now()}
|
||
|
||
if status == 3 {
|
||
now := time.Now()
|
||
if orderId, ok := mapData["i"].(float64); ok {
|
||
data["order_id"] = orderId
|
||
}
|
||
|
||
if ap, ok := mapData["ap"].(string); ok {
|
||
data["final_price"], _ = decimal.NewFromString(ap)
|
||
}
|
||
|
||
if num, ok := mapData["z"].(string); ok {
|
||
data["total_num"], _ = decimal.NewFromString(num)
|
||
}
|
||
|
||
data["trigger_time"] = &now
|
||
} else if status == 2 {
|
||
if orderId, ok := mapData["i"].(float64); ok {
|
||
data["order_id"] = orderId
|
||
}
|
||
}
|
||
|
||
db := e.Orm.Model(&DbModels.LineReverseOrder{}).
|
||
Where("order_sn =? and status != 3", orderSn).
|
||
Updates(data)
|
||
|
||
if db.Error != nil {
|
||
e.Log.Errorf("修改订单状态失败 orderSn:%s, err:%v", orderSn, db.Error)
|
||
}
|
||
|
||
if db.RowsAffected == 0 {
|
||
e.Log.Errorf("修改订单状态失败 orderSn:%s, 未找到订单", orderSn)
|
||
}
|
||
return db.Error
|
||
}
|
||
|
||
// 先保存主单,持仓信息 必须用双向持仓!
|
||
func (e *ReverseService) SaveMainOrder(mapData map[string]interface{}, apiInfo DbModels.LineApiUser) (DbModels.LineReverseOrder, error) {
|
||
now := time.Now()
|
||
symbol, err := maphelper.GetString(mapData, "s")
|
||
var reverseOrder DbModels.LineReverseOrder
|
||
if err != nil {
|
||
return reverseOrder, err
|
||
}
|
||
|
||
orderSn, err := maphelper.GetString(mapData, "c")
|
||
if err != nil {
|
||
return reverseOrder, err
|
||
}
|
||
|
||
side, err := maphelper.GetString(mapData, "S")
|
||
if err != nil {
|
||
return reverseOrder, err
|
||
}
|
||
|
||
positionSide, err := maphelper.GetString(mapData, "ps")
|
||
if err != nil {
|
||
return reverseOrder, err
|
||
}
|
||
|
||
mainType, _ := maphelper.GetString(mapData, "ot")
|
||
|
||
reverseOrder = DbModels.LineReverseOrder{
|
||
ApiId: apiInfo.Id,
|
||
Category: 0,
|
||
OrderSn: orderSn,
|
||
TriggerTime: &now,
|
||
Status: 3,
|
||
Symbol: symbol,
|
||
FollowOrderSn: "",
|
||
Type: mainType,
|
||
Price: maphelper.GetDecimal(mapData, "p"),
|
||
FinalPrice: maphelper.GetDecimal(mapData, "ap"),
|
||
TotalNum: maphelper.GetDecimal(mapData, "z"),
|
||
Side: side,
|
||
PositionSide: positionSide,
|
||
}
|
||
|
||
reverseOrder.PriceU = reverseOrder.Price
|
||
|
||
if !reverseOrder.Price.IsZero() && !reverseOrder.TotalNum.IsZero() {
|
||
reverseOrder.BuyPrice = reverseOrder.Price.Mul(reverseOrder.TotalNum)
|
||
}
|
||
|
||
if id, err := maphelper.GetFloat64(mapData, "i"); err == nil {
|
||
reverseOrder.OrderId = strconv.FormatFloat(id, 'f', -1, 64)
|
||
}
|
||
|
||
orderType, _ := maphelper.GetString(mapData, "ot")
|
||
switch orderType {
|
||
case "LIMIT", "MARKET":
|
||
reverseOrder.OrderType = 0
|
||
case "TAKE_PROFIT_MARKET", "TAKE_PROFIT":
|
||
reverseOrder.OrderType = 1
|
||
case "STOP_MARKET", "STOP", "TRAILING_STOP_MARKET":
|
||
reverseOrder.OrderType = 2
|
||
default:
|
||
return reverseOrder, fmt.Errorf("不支持的订单类型: %s", orderType)
|
||
}
|
||
|
||
if reverseOrder.PositionSide == "BOTH" {
|
||
return reverseOrder, errors.New("不支持的持仓类型,必须为双向持仓")
|
||
}
|
||
|
||
if err := e.Orm.Create(&reverseOrder).Error; err != nil {
|
||
e.Log.Errorf("保存主单失败:%v", err)
|
||
return reverseOrder, err
|
||
}
|
||
|
||
return reverseOrder, nil
|
||
}
|
||
|
||
// savePositionWithRetry 带重试机制的持仓保存
|
||
func (e *ReverseService) savePositionWithRetry(order *DbModels.LineReverseOrder, apiInfo *DbModels.LineApiUser, isMain, reducePosition bool) (bool, bool, error) {
|
||
const maxRetries = 3
|
||
for i := 0; i < maxRetries; i++ {
|
||
needReverseOrder, closePosition, err := e.savePosition(order, apiInfo, isMain, reducePosition)
|
||
if err == nil {
|
||
return needReverseOrder, closePosition, nil
|
||
}
|
||
e.Log.Warnf("持仓保存失败，重试 %d/%d: %v", i+1, maxRetries, err)
|
||
time.Sleep(time.Millisecond * 100 * time.Duration(i+1))
|
||
}
|
||
return false, false, fmt.Errorf("持仓保存失败，已重试 %d 次", maxRetries)
|
||
}
|
||
|
||
// 更新仓位信息
|
||
// apiInfo： 当前下单api信息
|
||
// return
|
||
// neeReverseOrder: 是否需要反单
|
||
// closePosition: true=平仓, false=减仓
|
||
// err error 错误信息
|
||
func (e *ReverseService) savePosition(order *DbModels.LineReverseOrder, apiInfo *DbModels.LineApiUser, isMain, reducePosition bool) (bool, bool, error) {
|
||
position := DbModels.LineReversePosition{}
|
||
positionSide := order.PositionSide
|
||
side := order.Side
|
||
totalNum := order.TotalNum
|
||
closePosition := false
|
||
needReverseOrder := false
|
||
|
||
symbol, err1 := cacheservice.GetTradeSet(global.EXCHANGE_BINANCE, order.Symbol, 1)
|
||
|
||
if err1 != nil {
|
||
e.Log.Errorf("获取交易对失败 symbol:%s err:%v", order.Symbol, err1)
|
||
}
|
||
|
||
var querySql string
|
||
sqlStr := ""
|
||
|
||
//如果是主单,存储仓位则是反单的持仓方向
|
||
if isMain {
|
||
if order.PositionSide == "LONG" {
|
||
positionSide = "SHORT"
|
||
} else {
|
||
positionSide = "LONG"
|
||
}
|
||
|
||
//减仓 判断是否为平仓
|
||
closePosition = e.getClosePosition(reducePosition, apiInfo, order, order.PositionSide, isMain)
|
||
|
||
if !reducePosition {
|
||
//反单止盈止损方向相反
|
||
if side == "SELL" {
|
||
side = "BUY"
|
||
} else {
|
||
side = "SELL"
|
||
}
|
||
|
||
position.ReverseApiId = apiInfo.ReverseApiId
|
||
position.Side = side
|
||
position.ApiId = order.ApiId
|
||
position.Symbol = order.Symbol
|
||
position.Status = 1
|
||
position.ReverseStatus = 0
|
||
position.PositionSide = positionSide
|
||
position.AveragePrice = order.FinalPrice
|
||
position.PositionNo = snowflakehelper.GetOrderNo()
|
||
}
|
||
querySql = "api_id =? and position_side =? and symbol =? and status =1"
|
||
|
||
//平仓
|
||
if closePosition {
|
||
totalNum = decimal.Zero
|
||
sqlStr = "UPDATE line_reverse_position set amount=@totalNum,updated_at=now(),status=2,version=version+1 where id =@id and status!=2 and version=@version"
|
||
} else if reducePosition {
|
||
//只减仓
|
||
sqlStr = "UPDATE line_reverse_position set amount=amount - @totalNum,updated_at=now(),average_price=@averagePrice,version=version+1 where id =@id and status!=2 and version=@version"
|
||
} else {
|
||
sqlStr = "UPDATE line_reverse_position set total_amount=total_amount + @totalNum,amount=amount + @totalNum,updated_at=now(),average_price=@averagePrice,version=version+1 where id =@id and status!=2 and version=@version"
|
||
}
|
||
} else {
|
||
querySql = "reverse_api_id =? and position_side =? and symbol =? and reverse_status in (0,1)"
|
||
//减仓 判断是否为平仓
|
||
closePosition = e.getClosePosition(reducePosition, apiInfo, order, order.PositionSide, isMain)
|
||
|
||
// 关键修复：确保反向持仓状态正确更新
|
||
if closePosition {
|
||
totalNum = decimal.Zero
|
||
// 增强的平仓更新逻辑，确保状态正确设置为2
|
||
sqlStr = "UPDATE line_reverse_position set reverse_amount=@totalNum,updated_at=now(),reverse_status=2,version=version+1 where id =@id and reverse_status !=2 and version=@version"
|
||
} else if reducePosition {
|
||
sqlStr = "UPDATE line_reverse_position set reverse_amount=reverse_amount - @totalNum,updated_at=now(),reverse_average_price=@averagePrice,version=version+1 where id =@id and reverse_status !=2 and version=@version"
|
||
} else {
|
||
sqlStr = "UPDATE line_reverse_position set total_reverse_amount=total_reverse_amount + @totalNum,reverse_amount=reverse_amount + @totalNum,updated_at=now(),reverse_status =1,reverse_average_price=@averagePrice,version=version+1 where id =@id and reverse_status !=2 and version=@version"
|
||
}
|
||
}
|
||
|
||
var averagePrice decimal.Decimal
|
||
var remainQuantity decimal.Decimal
|
||
|
||
err := e.Orm.Transaction(func(tx *gorm.DB) error {
|
||
err1 := tx.Model(&position).Where(querySql,
|
||
order.ApiId, positionSide, order.Symbol).First(&position).Error
|
||
|
||
if err1 != nil {
|
||
//主单仓位不存在,创建新仓位
|
||
if isMain && errors.Is(err1, gorm.ErrRecordNotFound) && !reducePosition {
|
||
// 初始化版本号
|
||
position.Version = 0
|
||
if err2 := tx.Create(&position).Error; err2 != nil {
|
||
return err2
|
||
}
|
||
|
||
averagePrice = position.AveragePrice
|
||
} else {
|
||
return err1
|
||
}
|
||
} else {
|
||
var totalAmount decimal.Decimal
|
||
var totalPrice decimal.Decimal
|
||
if !position.Amount.IsZero() && !position.AveragePrice.IsZero() {
|
||
if isMain {
|
||
totalPrice = position.Amount.Mul(position.AveragePrice)
|
||
totalAmount = position.Amount
|
||
} else {
|
||
totalPrice = position.ReverseAmount.Mul(position.ReverseAveragePrice)
|
||
totalAmount = position.ReverseAmount
|
||
}
|
||
|
||
//加仓
|
||
if !reducePosition {
|
||
totalPrice = totalPrice.Add(order.Price.Mul(order.TotalNum))
|
||
totalAmount = totalAmount.Add(order.TotalNum)
|
||
} else if reducePosition && !closePosition {
|
||
//只减仓
|
||
totalPrice = totalPrice.Sub(order.Price.Mul(order.TotalNum))
|
||
totalAmount = totalAmount.Sub(order.TotalNum)
|
||
}
|
||
}
|
||
|
||
if totalAmount.IsZero() || totalPrice.IsZero() {
|
||
if isMain {
|
||
averagePrice = position.AveragePrice
|
||
} else {
|
||
if position.ReverseAveragePrice.IsZero() {
|
||
averagePrice = order.Price
|
||
} else {
|
||
averagePrice = position.ReverseAveragePrice
|
||
}
|
||
}
|
||
} else {
|
||
//平仓
|
||
if closePosition {
|
||
if isMain {
|
||
averagePrice = position.AveragePrice
|
||
} else {
|
||
averagePrice = position.ReverseAveragePrice
|
||
}
|
||
} else {
|
||
averagePrice = totalPrice.Div(totalAmount).Truncate(int32(symbol.PriceDigit))
|
||
}
|
||
}
|
||
}
|
||
|
||
//关联订单的仓位id
|
||
if err2 := tx.Exec("UPDATE line_reverse_order set position_id=@positionId where id=@orderId and position_id = 0", sql.Named("positionId", position.Id), sql.Named("orderId", order.Id)).Error; err2 != nil {
|
||
return err2
|
||
}
|
||
|
||
// 使用乐观锁执行更新
|
||
dbResult := tx.Exec(sqlStr, sql.Named("totalNum", totalNum), sql.Named("id", position.Id), sql.Named("averagePrice", averagePrice), sql.Named("version", position.Version))
|
||
if dbResult.Error != nil {
|
||
return dbResult.Error
|
||
}
|
||
|
||
order.PositionId = position.Id
|
||
if dbResult.RowsAffected == 0 {
|
||
e.Log.Errorf("减仓数据 是否平仓单:%v :%v, 可能存在并发冲突", closePosition, order)
|
||
return fmt.Errorf("没有找到对应的持仓信息或版本冲突，position_id:%d, version:%d", position.Id, position.Version)
|
||
}
|
||
|
||
if reducePosition && !isMain {
|
||
remainQuantity = position.ReverseAmount.Sub(totalNum)
|
||
} else if !isMain {
|
||
remainQuantity = position.ReverseAmount.Add(totalNum)
|
||
}
|
||
|
||
//主单且对手单没有平仓
|
||
if isMain && position.ReverseStatus != 2 {
|
||
needReverseOrder = true
|
||
}
|
||
|
||
return nil
|
||
})
|
||
|
||
if !isMain && !closePosition {
|
||
e.doDefaultTakeStop(order, apiInfo, remainQuantity)
|
||
} else if !isMain && closePosition {
|
||
//取消剩余的委托
|
||
e.DoCancelTakeAndStop(order.Symbol, position.PositionSide, apiInfo)
|
||
}
|
||
|
||
return needReverseOrder, closePosition, err
|
||
}
|
||
|
||
// 获取是否为平仓状态
|
||
func (e *ReverseService) getClosePosition(reducePosition bool, apiInfo *DbModels.LineApiUser, order *DbModels.LineReverseOrder, positionSide string, isMain bool) bool {
|
||
closePosition := false
|
||
|
||
if reducePosition {
|
||
futApi := FutRestApi{}
|
||
holdData := HoldeData{}
|
||
err := futApi.GetPositionData(apiInfo, order.Symbol, positionSide, &holdData)
|
||
|
||
if err != nil {
|
||
e.Log.Errorf("获取剩余持仓信息失败 symbol:%s err:%v", order.Symbol, err)
|
||
lastPosition := DbModels.LineReversePosition{}
|
||
|
||
if err2 := e.Orm.Model(&DbModels.LineReversePosition{}).Where("position_side =? and symbol =? and status =1", positionSide, order.Symbol).First(&lastPosition).Error; err2 != nil {
|
||
e.Log.Errorf("获取上一次持仓信息失败 symbol:%s err:%v", order.Symbol, err2)
|
||
} else if isMain && lastPosition.Amount.Cmp(order.TotalNum) <= 0 {
|
||
//如果剩余仓位小于等于
|
||
closePosition = true
|
||
} else if !isMain && lastPosition.ReverseAmount.Cmp(order.TotalNum) <= 0 {
|
||
closePosition = true
|
||
}
|
||
} else if holdData.TotalQuantity.IsZero() {
|
||
closePosition = true
|
||
}
|
||
}
|
||
|
||
return closePosition
|
||
}
|
||
|
||
// 反向下单
|
||
// mainOrder: 主单信息
|
||
// reverseApiId: 反向apiId
|
||
// orderProportion: 反向下单比例
|
||
// reducePosition: 是否减仓
|
||
// closePosition: 是否平仓
|
||
func (e *ReverseService) DoAddReverseOrder(mainOrder *DbModels.LineReverseOrder, reverseApiInfo *DbModels.LineApiUser, orderProportion decimal.Decimal, reducePosition, closePosition bool) error {
|
||
order := DbModels.LineReverseOrder{}
|
||
order.ApiId = reverseApiInfo.Id
|
||
order.Category = 1
|
||
order.OrderSn = helper.GetOrderNo()
|
||
order.FollowOrderSn = mainOrder.OrderSn
|
||
order.Symbol = mainOrder.Symbol
|
||
order.OrderType = 0
|
||
|
||
switch mainOrder.PositionSide {
|
||
case "LONG":
|
||
order.PositionSide = "SHORT"
|
||
case "SHORT":
|
||
order.PositionSide = "LONG"
|
||
}
|
||
|
||
switch mainOrder.Side {
|
||
case "SELL":
|
||
order.Side = "BUY"
|
||
case "BUY":
|
||
order.Side = "SELL"
|
||
default:
|
||
return fmt.Errorf("不支持的订单类型 side:%s", mainOrder.Side)
|
||
}
|
||
|
||
if reducePosition && closePosition {
|
||
order.OrderType = 4
|
||
} else if reducePosition {
|
||
order.OrderType = 3
|
||
}
|
||
|
||
symbol, err := cacheservice.GetTradeSet(global.EXCHANGE_BINANCE, mainOrder.Symbol, 1)
|
||
|
||
if err != nil {
|
||
e.Log.Errorf("获取交易对信息失败 symbol:%s custom:%s :%v", mainOrder.Symbol, mainOrder.OrderSn, err)
|
||
return err
|
||
}
|
||
|
||
setting, err := cacheservice.GetReverseSetting(e.Orm)
|
||
|
||
if err != nil {
|
||
e.Log.Errorf("获取反单设置失败 symbol:%s custom:%s :%v", mainOrder.Symbol, mainOrder.OrderSn, err)
|
||
return err
|
||
}
|
||
|
||
signPrice, _ := decimal.NewFromString(symbol.LastPrice)
|
||
price := signPrice.Truncate(int32(symbol.PriceDigit))
|
||
|
||
if price.Cmp(decimal.Zero) <= 0 {
|
||
e.Log.Errorf("获取最新价格失败 symbol:%s custom:%s 单价小于0", mainOrder.Symbol, mainOrder.OrderSn)
|
||
return errors.New("获取最新价格失败")
|
||
}
|
||
|
||
var percent decimal.Decimal
|
||
switch {
|
||
case order.PositionSide == "LONG" && order.Side == "BUY", order.PositionSide == "SHORT" && order.Side == "BUY":
|
||
percent = decimal.NewFromInt(100).Add(setting.ReversePremiumRatio)
|
||
case order.PositionSide == "SHORT" && order.Side == "SELL", order.PositionSide == "LONG" && order.Side == "SELL":
|
||
percent = decimal.NewFromInt(100).Sub(setting.ReversePremiumRatio)
|
||
default:
|
||
return fmt.Errorf("不支持的订单类型 ps:%s, side:%s", order.PositionSide, order.Side)
|
||
}
|
||
|
||
percent = percent.Div(decimal.NewFromInt(100)).Truncate(4)
|
||
//计算溢价单价
|
||
price = price.Mul(percent).Truncate(int32(symbol.PriceDigit))
|
||
var amount decimal.Decimal
|
||
|
||
//平仓单直接卖出全部数量
|
||
if closePosition {
|
||
var position DbModels.LineReversePosition
|
||
if err1 := e.Orm.Model(position).
|
||
Where("position_side =? and reverse_api_id =? and reverse_status =1", order.PositionSide, order.ApiId).
|
||
Select("reverse_amount").
|
||
Find(&position).Error; err1 != nil {
|
||
e.Log.Errorf("获取剩余仓位失败 symbol:%s custom:%s :%v", order.Symbol, order.OrderSn, err1)
|
||
|
||
if len(err1.Error()) < 255 {
|
||
order.Remark = err1.Error()
|
||
} else {
|
||
order.Remark = err1.Error()[:254]
|
||
}
|
||
}
|
||
|
||
amount = position.ReverseAmount
|
||
|
||
if amount.IsZero() {
|
||
order.Remark = "没有持仓数量"
|
||
}
|
||
} else {
|
||
proportion := decimal.NewFromInt(100)
|
||
|
||
if orderProportion.Cmp(decimal.Zero) > 0 {
|
||
proportion = orderProportion
|
||
}
|
||
|
||
//反向下单百分比
|
||
proportion = proportion.Div(decimal.NewFromInt(100)).Truncate(4)
|
||
|
||
amount = mainOrder.TotalNum.Mul(proportion).Truncate(int32(symbol.AmountDigit))
|
||
|
||
logger.Info("反向下单比例 %d ,原始数量：%d，反向下单数量：%d", proportion, mainOrder.TotalNum, amount)
|
||
|
||
if amount.Cmp(decimal.Zero) <= 0 {
|
||
e.Log.Errorf("计算数量失败 symbol:%s custom:%s 数量小于0", mainOrder.Symbol, mainOrder.OrderSn)
|
||
return errors.New("计算数量失败")
|
||
}
|
||
}
|
||
|
||
order.TotalNum = amount
|
||
order.Price = price
|
||
order.PriceU = price
|
||
order.BuyPrice = amount.Mul(price).Truncate(int32(symbol.PriceDigit))
|
||
order.Status = 1
|
||
order.Type = setting.ReverseOrderType
|
||
order.SignPrice = signPrice
|
||
order.PositionId = mainOrder.PositionId
|
||
|
||
if order.Remark != "" {
|
||
order.Status = 8
|
||
}
|
||
|
||
if err := e.Orm.Model(&order).Create(&order).Error; err != nil {
|
||
e.Log.Errorf("保存反单失败 symbol:%s custom:%s :%v", mainOrder.Symbol, mainOrder.OrderSn, err)
|
||
return err
|
||
}
|
||
|
||
if order.Status == 1 {
|
||
err = e.DoBianceOrder(&order, reverseApiInfo, &setting, reducePosition, closePosition)
|
||
|
||
//Biance下单成共 且为平仓单时 取消止盈止损
|
||
if err == nil && closePosition {
|
||
e.DoCancelTakeProfitBatch(symbol.GetSymbol(), order.PositionSide, order.Side, -1, reverseApiInfo)
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// 取消止盈止损订单
|
||
// symbol: 交易对
|
||
// positionSide: 持仓方向
|
||
// side: 订单方向
|
||
// orderType: 订单类型 -1-全部 1-止盈 2-止损
|
||
// apiInfo: 下单api
|
||
func (e *ReverseService) DoCancelTakeProfitBatch(symbol, positionSide, side string, orderType int, apiInfo *DbModels.LineApiUser) error {
|
||
orderSns := e.GetTakeProfitBatch(symbol, positionSide, side, apiInfo.Id, orderType)
|
||
|
||
if len(orderSns) == 0 {
|
||
return nil
|
||
}
|
||
|
||
if len(orderSns) > 0 {
|
||
futApi := FutRestApi{}
|
||
err := futApi.CancelBatchFutOrderLoop(*apiInfo, symbol, orderSns)
|
||
|
||
if err != nil {
|
||
e.Log.Errorf("币安撤单失败 symbol:%s custom:%v :%v", symbol, orderSns, err)
|
||
return err
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// 取消止盈和止损单
|
||
func (e *ReverseService) DoCancelTakeAndStop(symbol, positionSide string, apiInfo *DbModels.LineApiUser) error {
|
||
var orderSns []string
|
||
|
||
e.Orm.Model(&DbModels.LineReverseOrder{}).Where("symbol =? and position_side =? and status =2", symbol, positionSide).Pluck("order_sn", &orderSns)
|
||
|
||
if len(orderSns) > 0 {
|
||
futApi := FutRestApi{}
|
||
|
||
if err := futApi.CancelBatchFutOrderLoop(*apiInfo, symbol, orderSns); err != nil {
|
||
e.Log.Errorf("币安撤单失败 symbol:%s custom:%v :%v", symbol, orderSns, err)
|
||
return err
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// 获取止盈止损订单
|
||
// symbol: 交易对
|
||
// positionSide: 持仓方向
|
||
// side: 订单方向
|
||
// apiId: 币安apiId
|
||
// orderType: 订单类型 -1-全部 1-止盈 2-止损
|
||
func (e *ReverseService) GetTakeProfitBatch(symbol, positionSide, side string, apiId int, orderType int) []string {
|
||
var orderSns []string
|
||
orderTypes := []int{1, 2}
|
||
|
||
if orderType == 1 {
|
||
orderTypes = []int{1}
|
||
} else if orderType == 2 {
|
||
orderTypes = []int{2}
|
||
}
|
||
|
||
e.Orm.Model(&DbModels.LineReverseOrder{}).Where("symbol =? and position_side =? and side = ? and status =2 and order_type in ?", symbol, positionSide, side, orderTypes).Pluck("order_sn", &orderSns)
|
||
|
||
return orderSns
|
||
}
|
||
|
||
// 处理币安订单
|
||
// order: 反单信息
|
||
// apiInfo: 币安api信息
|
||
func (e *ReverseService) DoBianceOrder(order *DbModels.LineReverseOrder, apiInfo *DbModels.LineApiUser, setting *DbModels.LineReverseSetting, reducePosition, closePosition bool) error {
|
||
futApiV2 := FuturesResetV2{Service: e.Service}
|
||
orderType := setting.ReverseOrderType
|
||
|
||
if orderType == "" {
|
||
orderType = "LIMIT"
|
||
}
|
||
|
||
params := FutOrderPlace{
|
||
ApiId: apiInfo.Id,
|
||
Symbol: order.Symbol,
|
||
PositionSide: order.PositionSide,
|
||
Side: order.Side,
|
||
OrderType: orderType,
|
||
Quantity: order.TotalNum,
|
||
Price: order.Price,
|
||
NewClientOrderId: order.OrderSn,
|
||
}
|
||
|
||
err := futApiV2.OrderPlaceLoop(apiInfo, params)
|
||
|
||
if err != nil {
|
||
e.Log.Errorf("币安下单失败 symbol:%s custom:%s :%v", order.Symbol, order.OrderSn, err)
|
||
remark := err.Error()
|
||
|
||
if len(remark) > 255 {
|
||
remark = remark[:254]
|
||
}
|
||
|
||
if err1 := e.Orm.Model(&order).Where("id =? and status !=3", order.Id).Updates(map[string]interface{}{"status": 8, "remark": remark, "updated_at": time.Now()}).Error; err1 != nil {
|
||
e.Log.Errorf("更新订单状态失败 symbol:%s custom:%s :%v", err1)
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// 处理默认止盈止损
|
||
// order: 订单信息
|
||
// apiInfo: api信息
|
||
// Optimized Reverse Order Handling
|
||
// File: reverse_order_handler.go
|
||
|
||
func (e *ReverseService) doDefaultTakeStop(order *DbModels.LineReverseOrder, apiInfo *DbModels.LineApiUser, totalNum decimal.Decimal) error {
|
||
if totalNum.LessThanOrEqual(decimal.Zero) {
|
||
return nil
|
||
}
|
||
|
||
orders, err := e.getActiveReverseOrders(order.PositionId)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if len(orders) == 2 {
|
||
return nil
|
||
}
|
||
|
||
setting, err := GetReverseSetting(e.Orm)
|
||
if err != nil {
|
||
e.Log.Errorf("获取反单设置失败:%v", err)
|
||
return err
|
||
}
|
||
|
||
symbol, err := cacheservice.GetTradeSet(global.EXCHANGE_BINANCE, order.Symbol, 1)
|
||
if err != nil {
|
||
e.Log.Errorf("获取交易对信息失败:%v", err)
|
||
return err
|
||
}
|
||
|
||
side := e.getOppositeSide(order.Side)
|
||
lastPrice, _ := decimal.NewFromString(symbol.LastPrice)
|
||
now := time.Now()
|
||
|
||
types := []struct {
|
||
Enabled bool
|
||
CheckTypes []string
|
||
OrderType string
|
||
Ratio decimal.Decimal
|
||
IsTakeProfit bool
|
||
}{
|
||
{!setting.TakeProfitRatio.IsZero(), []string{"TAKE_PROFIT_MARKET", "TAKE_PROFIT"}, "TAKE_PROFIT_MARKET", setting.TakeProfitRatio, true},
|
||
{!setting.StopLossRatio.IsZero(), []string{"STOP_MARKET", "STOP"}, "STOP_MARKET", setting.StopLossRatio, false},
|
||
}
|
||
|
||
for _, t := range types {
|
||
if t.Enabled && !e.hasOrderType(orders, t.CheckTypes...) {
|
||
price := e.calculatePrice(order.PositionSide, order.FinalPrice, t.Ratio, t.IsTakeProfit)
|
||
err := e.createReverseOrder(CreateOrderParams{
|
||
Order: order,
|
||
ApiInfo: apiInfo,
|
||
Symbol: &symbol,
|
||
Side: side,
|
||
OrderType: t.OrderType,
|
||
Price: price,
|
||
TotalNum: totalNum,
|
||
Now: now,
|
||
LastPrice: lastPrice,
|
||
Close: true,
|
||
PositionId: order.PositionId,
|
||
})
|
||
if err != nil {
|
||
e.Log.Errorf("止盈止损下单失败：%v", err)
|
||
}
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// 重下止盈止损
|
||
// mapData:
|
||
func (e *ReverseService) ReTakeOrStopOrder(mapData *map[string]interface{}, orderSn string, mainApiInfo *DbModels.LineApiUser, symbol *models.TradeSet) error {
|
||
side, err := maphelper.GetString(*mapData, "S")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
ot, err := maphelper.GetString(*mapData, "ot")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
positionSide, err := maphelper.GetString(*mapData, "ps")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
close := maphelper.GetBool(*mapData, "cp")
|
||
stopPrice := maphelper.GetDecimal(*mapData, "sp")
|
||
if stopPrice.IsZero() {
|
||
e.Log.Errorf("获取止盈止损单触发价失败 symbol:%s custom:%s :%v", symbol, orderSn, err)
|
||
return err
|
||
}
|
||
apiInfo, err := GetApiInfo(mainApiInfo.ReverseApiId)
|
||
if err != nil {
|
||
e.Log.Errorf("根据主单api获取反单api失败 symbol:%s custom:%s :%v", symbol, orderSn, err)
|
||
return err
|
||
}
|
||
|
||
side = e.getOppositeSide(side)
|
||
if positionSide == "LONG" {
|
||
positionSide = "SHORT"
|
||
} else {
|
||
positionSide = "LONG"
|
||
}
|
||
|
||
var orderType int
|
||
switch ot {
|
||
case "STOP_MARKET", "STOP":
|
||
orderType = 2
|
||
case "TAKE_PROFIT_MARKET", "TAKE_PROFIT":
|
||
orderType = 1
|
||
default:
|
||
return fmt.Errorf("不支持的订单类型 ot:%s", ot)
|
||
}
|
||
|
||
var reversePosition DbModels.LineReversePosition
|
||
e.Orm.Model(&reversePosition).
|
||
Where("symbol =? and reverse_api_id =? and position_side =? and reverse_status =1", symbol.GetSymbol(), apiInfo.Id, positionSide).
|
||
First(&reversePosition)
|
||
if reversePosition.Id == 0 {
|
||
e.Log.Errorf("获取反单持仓失败 symbol:%s custom:%s :%v", symbol, orderSn, err)
|
||
return err
|
||
}
|
||
|
||
mainPercent := stopPrice.Div(reversePosition.AveragePrice)
|
||
mainPercent = (mainPercent.Sub(decimal.NewFromInt(1))).Abs().Truncate(4)
|
||
|
||
var percent decimal.Decimal
|
||
switch {
|
||
case orderType == 2 && positionSide == "LONG", orderType == 1 && positionSide == "SHORT":
|
||
percent = decimal.NewFromInt(1).Sub(mainPercent)
|
||
case orderType == 2 && positionSide == "SHORT", orderType == 1 && positionSide == "LONG":
|
||
percent = decimal.NewFromInt(1).Add(mainPercent)
|
||
default:
|
||
return fmt.Errorf("不支持的订单类型 ot:%s, ps:%s", ot, positionSide)
|
||
}
|
||
|
||
now := time.Now()
|
||
price := reversePosition.AveragePrice.Mul(percent).Truncate(int32(symbol.PriceDigit))
|
||
lastPrice, _ := decimal.NewFromString(symbol.LastPrice)
|
||
|
||
return e.createReverseOrder(CreateOrderParams{
|
||
ApiInfo: &apiInfo,
|
||
Symbol: symbol,
|
||
Side: side,
|
||
OrderType: ot,
|
||
Price: price,
|
||
TotalNum: reversePosition.TotalReverseAmount,
|
||
Now: now,
|
||
LastPrice: lastPrice,
|
||
Close: close,
|
||
PositionId: reversePosition.Id,
|
||
OrderSn: orderSn,
|
||
PositionSide: positionSide,
|
||
})
|
||
}
|
||
|
||
func (e *ReverseService) getActiveReverseOrders(positionId int) ([]DbModels.LineReverseOrder, error) {
|
||
var orders []DbModels.LineReverseOrder
|
||
err := e.Orm.Model(&DbModels.LineReverseOrder{}).
|
||
Where("position_id =? and status =2", positionId).
|
||
Select("id,position_side,side,type").Find(&orders).Error
|
||
if err != nil {
|
||
e.Log.Errorf("获取订单信息失败:%v", err)
|
||
}
|
||
return orders, err
|
||
}
|
||
|
||
func (e *ReverseService) getOppositeSide(side string) string {
|
||
if side == "SELL" {
|
||
return "BUY"
|
||
}
|
||
return "SELL"
|
||
}
|
||
|
||
func (e *ReverseService) hasOrderType(orders []DbModels.LineReverseOrder, types ...string) bool {
|
||
typeSet := make(map[string]bool)
|
||
for _, t := range types {
|
||
typeSet[t] = true
|
||
}
|
||
for _, o := range orders {
|
||
if typeSet[o.Type] {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func (e *ReverseService) calculatePrice(positionSide string, base decimal.Decimal, ratio decimal.Decimal, isTakeProfit bool) decimal.Decimal {
|
||
adjust := decimal.NewFromInt(100)
|
||
if positionSide == "LONG" {
|
||
if isTakeProfit {
|
||
return base.Mul(adjust.Add(ratio).Div(adjust)).Truncate(4)
|
||
}
|
||
return base.Mul(adjust.Sub(ratio).Div(adjust)).Truncate(4)
|
||
}
|
||
if isTakeProfit {
|
||
return base.Mul(adjust.Sub(ratio).Div(adjust)).Truncate(4)
|
||
}
|
||
return base.Mul(adjust.Add(ratio).Div(adjust)).Truncate(4)
|
||
}
|
||
|
||
type CreateOrderParams struct {
|
||
ApiInfo *DbModels.LineApiUser
|
||
Order *DbModels.LineReverseOrder
|
||
Symbol *models.TradeSet
|
||
Side string
|
||
OrderType string
|
||
Price decimal.Decimal
|
||
TotalNum decimal.Decimal
|
||
Now time.Time
|
||
LastPrice decimal.Decimal
|
||
Close bool
|
||
PositionId int
|
||
OrderSn string
|
||
PositionSide string
|
||
}
|
||
|
||
func (e *ReverseService) createReverseOrder(params CreateOrderParams) error {
|
||
orderSn := params.OrderSn
|
||
if orderSn == "" {
|
||
orderSn = helper.GetOrderNo()
|
||
}
|
||
if params.PositionSide == "" && params.Order != nil {
|
||
params.PositionSide = params.Order.PositionSide
|
||
}
|
||
newOrder := DbModels.LineReverseOrder{
|
||
PositionId: params.PositionId,
|
||
OrderSn: orderSn,
|
||
OrderType: getOrderType(params.OrderType),
|
||
Status: 1,
|
||
Price: params.Price,
|
||
TotalNum: params.TotalNum,
|
||
Symbol: params.Symbol.GetSymbol(),
|
||
Side: params.Side,
|
||
PositionSide: params.PositionSide,
|
||
FollowOrderSn: params.OrderSn,
|
||
Type: params.OrderType,
|
||
SignPrice: params.LastPrice,
|
||
Category: 1,
|
||
ApiId: params.ApiInfo.Id,
|
||
IsAddPosition: 2,
|
||
TriggerTime: ¶ms.Now,
|
||
BuyPrice: params.TotalNum.Mul(params.Price).Truncate(int32(params.Symbol.PriceDigit)),
|
||
}
|
||
|
||
if err := e.Orm.Create(&newOrder).Error; err != nil {
|
||
e.Log.Errorf("保存反单止盈止损失败 symbol:%s custom:%s :%v", params.Symbol.GetSymbol(), newOrder.OrderSn, err)
|
||
return err
|
||
}
|
||
|
||
futApiV2 := FuturesResetV2{Service: e.Service}
|
||
params2 := FutOrderPlace{
|
||
ApiId: params.ApiInfo.Id,
|
||
Symbol: params.Symbol.GetSymbol(),
|
||
PositionSide: newOrder.PositionSide,
|
||
Side: newOrder.Side,
|
||
OrderType: newOrder.Type,
|
||
Quantity: newOrder.TotalNum,
|
||
Price: newOrder.Price,
|
||
StopPrice: newOrder.Price,
|
||
Profit: newOrder.Price,
|
||
NewClientOrderId: newOrder.OrderSn,
|
||
ClosePosition: params.Close,
|
||
}
|
||
err := futApiV2.OrderPlaceLoop(params.ApiInfo, params2)
|
||
if err != nil {
|
||
e.Log.Errorf("币安下单失败 symbol:%s custom:%s :%v", params.Symbol.GetSymbol(), newOrder.OrderSn, err)
|
||
e.Orm.Model(&newOrder).Updates(map[string]interface{}{"status": 8, "remark": err.Error(), "updated_at": time.Now()})
|
||
return err
|
||
}
|
||
e.DoCancelTakeProfitBatch(params.Symbol.GetSymbol(), newOrder.PositionSide, newOrder.Side, newOrder.OrderType, params.ApiInfo)
|
||
return nil
|
||
}
|
||
|
||
func getOrderType(t string) int {
|
||
if t == "TAKE_PROFIT_MARKET" || t == "TAKE_PROFIT" {
|
||
return 1
|
||
}
|
||
return 2
|
||
}
|