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-06 18:03:09 +08:00
parent 07847a2d9e
commit c0b8749eef
15 changed files with 546 additions and 720 deletions
Download Patch File Download Diff File Expand all files Collapse all files

222
services/binanceservice/binancerest.go
View File

@ -14,13 +14,9 @@ import (
"go-admin/models/spot"
"go-admin/pkg/httputils"
"go-admin/pkg/utility"
"go-admin/pkg/utility/snowflakehelper"
"strconv"
"strings"
"time"
"github.com/go-redis/redis/v8"
"github.com/jinzhu/copier"
"github.com/shopspring/decimal"
"gorm.io/gorm"
@ -244,14 +240,6 @@ func (e SpotRestApi) OrderPlace(orm *gorm.DB, params OrderPlacementService) erro
if err := sonic.Unmarshal(resp, &dataMap); err != nil {
return fmt.Errorf("api_id:%d 交易对:%s 下单失败:%+v", apiUserInfo.Id, params.Symbol, err.Error())
}
//code, ok := dataMap["code"]
//if !ok {
// return fmt.Errorf("api_id:%d 交易对:%s 下单失败:%s", apiUserInfo.Id, params.Symbol, dataMap["message"])
//
//}
//if code.(float64) != 200 {
// return fmt.Errorf("api_id:%d 交易对:%s 下单失败:%s", apiUserInfo.Id, params.Symbol, dataMap["message"])
//}
return nil
}
@ -341,48 +329,6 @@ func (e SpotRestApi) CancelOpenOrderByOrderSn(apiUserInfo DbModels.LineApiUser,
return nil
}
// CalcEntryCashPriceByOrder 计算现货主单均价
func CalcEntryCashPriceByOrder(orderInfo *DbModels.LinePreOrder, orm *gorm.DB) (EntryPriceResult, error) {
//找到主单成交的记录
var id int
if orderInfo.Pid > 0 {
id = orderInfo.Pid
} else {
id = orderInfo.Id
}
orderLists := make([]DbModels.LinePreOrder, 0)
orm.Model(&DbModels.LinePreOrder{}).Where(" symbol = ? AND site = 'BUY' AND order_type in ('1','8') AND status ='9' AND (id = ? OR pid = ?)", orderInfo.Symbol, id, id).Find(&orderLists)
var (
totalNum decimal.Decimal //总成交数量
totalMoney decimal.Decimal //总金额
entryPrice decimal.Decimal //均价
initPrice decimal.Decimal //主单下单价格
firstId int //主单id
)
for _, list := range orderLists {
num, _ := decimal.NewFromString(list.Num)
totalNum = totalNum.Add(num)
price, _ := decimal.NewFromString(list.Price)
totalMoney = totalMoney.Add(num.Mul(price))
if list.OrderType == "1" {
firstId = list.Id
initPrice, _ = decimal.NewFromString(list.Price)
}
}
if totalNum.GreaterThan(decimal.Zero) {
entryPrice = totalMoney.Div(totalNum)
}
return EntryPriceResult{
TotalNum: totalNum,
EntryPrice: entryPrice,
FirstPrice: initPrice,
FirstId: firstId,
TotalMoney: totalMoney,
}, nil
}
// ClosePosition 平仓
// symbol 交易对
// orderSn 平仓单号
@ -459,135 +405,15 @@ func GetClient(apiUserInfo *DbModels.LineApiUser) *helper.BinanceClient {
return client
}
/*
重下止盈单
*/
func (e SpotRestApi) reTakeOrder(parentOrderInfo DbModels.LinePreOrder, orm *gorm.DB) {
price, _ := decimal.NewFromString(parentOrderInfo.Price)
num, _ := decimal.NewFromString(parentOrderInfo.Num)
parentId := parentOrderInfo.Id
if parentOrderInfo.Pid > 0 {
parentId = parentOrderInfo.Pid
}
var takePrice decimal.Decimal
holdeAKey := fmt.Sprintf(rediskey.HoldeA, parentId)
holdeAVal, _ := helper.DefaultRedis.GetString(holdeAKey)
holdeA := HoldeData{}
if holdeAVal != "" {
sonic.Unmarshal([]byte(holdeAVal), &holdeA)
}
//查询持仓失败
if holdeA.Id == 0 {
log.Error("查询A账号持仓失败")
return
}
//加仓次数大于0 就需要使用均价
if holdeA.PositionIncrementCount > 0 {
price = holdeA.AveragePrice
num = holdeA.TotalQuantity
}
if parentOrderInfo.Site == "BUY" {
takePrice = price.Mul(decimal.NewFromInt(100).Add(parentOrderInfo.ProfitRate)).Div(decimal.NewFromInt(100))
} else {
takePrice = price.Mul(decimal.NewFromInt(100).Sub(parentOrderInfo.ProfitRate)).Div(decimal.NewFromInt(100))
}
var takeOrder, oldTakeOrder DbModels.LinePreOrder
if err := orm.Model(&oldTakeOrder).Where("pid= ? AND order_type ='5'", parentId).First(&oldTakeOrder).Error; err != nil {
log.Error("查询止盈单失败")
return
}
tradeset, _ := GetTradeSet(oldTakeOrder.Symbol, 0)
if tradeset.Coin == "" {
log.Error("查询交易对失败")
return
}
copier.Copy(&takeOrder, &oldTakeOrder)
takeOrder.OrderSn = strconv.FormatInt(snowflakehelper.GetOrderId(), 10)
takeOrder.Price = takePrice.Truncate(int32(tradeset.PriceDigit)).String()
takeOrder.Num = num.Mul(decimal.NewFromFloat(0.995)).Truncate(int32(tradeset.AmountDigit)).String()
takeOrder.Desc = ""
takeOrder.Status = 0
takeOrder.Id = 0
if err := orm.Create(&takeOrder).Error; err != nil {
log.Error("创建新止盈单失败")
return
}
params := OrderPlacementService{
ApiId: parentOrderInfo.ApiId,
Symbol: parentOrderInfo.Symbol,
Price: utility.StrToDecimal(takeOrder.Price),
Quantity: utility.StringToDecimal(takeOrder.Num),
Side: "SELL",
Type: "TAKE_PROFIT_LIMIT",
TimeInForce: "GTC",
StopPrice: utility.StrToDecimal(takeOrder.Price),
NewClientOrderId: takeOrder.OrderSn,
}
apiUserInfo, _ := GetApiInfo(parentOrderInfo.ApiId)
if apiUserInfo.Id == 0 {
log.Error("获取用户api失败")
return
}
if err := CancelSpotOrder(parentOrderInfo.Symbol, &apiUserInfo, "SELL"); err != nil {
log.Error("取消旧止盈失败 err:", err)
} else {
if err := orm.Model(&DbModels.LinePreOrder{}).Where("pid = ? AND order_type =5 AND status in ('0','1','5') AND order_sn !=?", parentId, takeOrder.OrderSn).Update("status", "4").Error; err != nil {
log.Error("更新旧止盈单取消状态失败 err:", err)
}
}
var err error
for x := 1; x <= 4; x++ {
err = e.OrderPlace(orm, params)
if err == nil {
break
}
log.Error("下止盈单失败 第", utility.IntToString(x), "次", " err:", err)
time.Sleep(2 * time.Second * time.Duration(x))
}
if err != nil {
log.Error("重新下单止盈失败 err:", err)
if err1 := orm.Model(&DbModels.LinePreOrder{}).Where("order_sn =?", takeOrder.OrderSn).
Updates(map[string]interface{}{"status": "2", "desc": err.Error()}).Error; err1 != nil {
log.Error("重新下单止盈 修改订单失败 pid:", parentId, " takePrice:", takePrice, " err:", err1)
}
}
//修改止盈单信息
if err := orm.Model(&DbModels.LinePreOrder{}).Where("pid =? AND order_type ='5'", parentId).
Updates(map[string]interface{}{"price": takePrice, "rate": parentOrderInfo.ProfitRate}).Error; err != nil {
log.Error("重新下单止盈 修改订单失败 pid:", parentId, " takePrice:", takePrice, " rate:", parentOrderInfo.ProfitRate, " err:", err)
}
}
/*
判断是否触发
*/
func JudgeSpotPrice(trade models.TradeSet) {
preOrderVal, _ := helper.DefaultRedis.GetAllList(rediskey.PreSpotOrderList)
key := fmt.Sprintf(rediskey.PreSpotOrderList, global.EXCHANGE_BINANCE)
preOrderVal, _ := helper.DefaultRedis.GetAllList(key)
db := GetDBConnection()
if len(preOrderVal) == 0 {
// log.Debug("没有现货预下单")
return
}
@ -622,35 +448,20 @@ func SpotOrderLock(db *gorm.DB, v *dto.PreOrderRedisList, item string, spotApi S
} else if ok {
defer lock.Release()
key := fmt.Sprintf(rediskey.UserHolding, v.ApiId)
symbols, err := helper.DefaultRedis.GetAllList(key)
if err != nil && err != redis.Nil {
log.Error("获取用户持仓失败", err)
return
}
key := fmt.Sprintf(rediskey.PreSpotOrderList, global.EXCHANGE_BINANCE)
preOrder := DbModels.LinePreOrder{}
if err := db.Where("id = ?", v.Id).First(&preOrder).Error; err != nil {
log.Error("获取预下单失败", err)
if errors.Is(err, gorm.ErrRecordNotFound) {
log.Error("不存在待触发主单", item)
helper.DefaultRedis.LRem(rediskey.PreSpotOrderList, item)
helper.DefaultRedis.LRem(key, item)
}
return
}
//获取代币 是否已有持仓
coin := utility.ReplaceSuffix(preOrder.Symbol, preOrder.QuoteSymbol, "")
if utility.ContainsStr(symbols, coin) {
log.Debug("已有持仓")
return
}
hasrecord, _ := helper.DefaultRedis.IsElementInList(rediskey.PreSpotOrderList, item)
hasrecord, _ := helper.DefaultRedis.IsElementInList(key, item)
if !hasrecord {
log.Error("不存在待触发主单", item)
@ -673,14 +484,14 @@ func SpotOrderLock(db *gorm.DB, v *dto.PreOrderRedisList, item string, spotApi S
if err := spotApi.OrderPlace(db, params); err != nil {
log.Error("下单失败", v.Symbol, " err:", err)
err := db.Model(&DbModels.LinePreOrder{}).Where("id =? AND status ='0'", preOrder.Id).Updates(map[string]interface{}{"status": "2", "desc": err.Error()}).Error
err := db.Model(&DbModels.LinePreOrder{}).Where("id =? AND status =0", preOrder.Id).Updates(map[string]interface{}{"status": "2", "desc": err.Error()}).Error
if err != nil {
log.Error("下单失败后修改订单失败")
}
if preOrderVal != "" {
if _, err := helper.DefaultRedis.LRem(rediskey.PreSpotOrderList, preOrderVal); err != nil {
if _, err := helper.DefaultRedis.LRem(key, preOrderVal); err != nil {
log.Error("删除redis 预下单失败:", err)
}
}
@ -689,31 +500,14 @@ func SpotOrderLock(db *gorm.DB, v *dto.PreOrderRedisList, item string, spotApi S
}
if preOrderVal != "" {
if _, err := helper.DefaultRedis.LRem(rediskey.PreSpotOrderList, preOrderVal); err != nil {
if _, err := helper.DefaultRedis.LRem(key, preOrderVal); err != nil {
log.Error("删除redis 预下单失败:", err)
}
// spotPreOrders, _ := helper.DefaultRedis.GetAllList(rediskey.PreSpotOrderList)
// futuresPreOrders, _ := helper.DefaultRedis.GetAllList(rediskey.PreFutOrderList)
// var order dto.PreOrderRedisList
// for _, item := range spotPreOrders {
// sonic.Unmarshal([]byte(item), &order)
// if order.QuoteSymbol == "" {
// }
// }
}
if err := db.Model(&DbModels.LinePreOrder{}).Where("id =? AND status ='0'", preOrder.Id).Update("status", "1").Error; err != nil {
log.Error("更新预下单状态失败 ordersn:", v.OrderSn, " status:1")
}
if err := helper.DefaultRedis.RPushList(key, coin); err != nil {
log.Error("写入用户持仓失败", v.Symbol)
}
return
} else {
log.Error("获取锁失败")

13
services/binanceservice/binanceservice_test.go
View File

@ -2,13 +2,14 @@ package binanceservice
import (
"fmt"
"github.com/bytedance/sonic"
"go-admin/app/admin/models"
"go-admin/common/helper"
"go-admin/pkg/utility"
"go-admin/pkg/utility/snowflakehelper"
"testing"
"github.com/bytedance/sonic"
"github.com/shopspring/decimal"
"gorm.io/driver/mysql"
"gorm.io/gorm"
@ -53,16 +54,6 @@ func TestPositionV3(t *testing.T) {
fmt.Println(v3)
}
func TestInsertLog(t *testing.T) {
dsn := "root:root@tcp(192.168.1.12:3306)/gp-bian?charset=utf8mb4&parseTime=True&loc=Local&timeout=1000ms"
db, _ := gorm.Open(mysql.Open(dsn), &gorm.Config{})
//初始redis 链接
helper.InitDefaultRedis("192.168.1.12:6379", "", 0)
helper.InitLockRedisConn("192.168.1.12:6379", "", "0")
InsertProfitLogs(db, "367452130811838464", decimal.NewFromInt(20), decimal.NewFromFloat(0.34078000))
}
func TestCancelSpotOrder(t *testing.T) {
//dsn := "root:root@tcp(192.168.1.12:3306)/gp-bian?charset=utf8mb4&parseTime=True&loc=Local&timeout=1000ms"
//db, _ := gorm.Open(mysql.Open(dsn), &gorm.Config{})

19
services/binanceservice/commonservice.go
View File

@ -16,6 +16,7 @@ import (
"github.com/bytedance/sonic"
"github.com/go-admin-team/go-admin-core/logger"
log "github.com/go-admin-team/go-admin-core/logger"
"github.com/go-admin-team/go-admin-core/sdk"
"github.com/shopspring/decimal"
"gorm.io/gorm"
)
@ -329,3 +330,21 @@ func MainClosePositionClearCache(mainOrderId int, coverType int) {
}
}
}
// 获取数据库连接
func GetDBConnection() *gorm.DB {
dbs := sdk.Runtime.GetDb()
for _, db := range dbs {
return db
}
return nil
}
// 查询订单
func getPreOrder(db *gorm.DB, orderSn interface{}) (*DbModels.LinePreOrder, error) {
preOrder := &DbModels.LinePreOrder{}
if err := db.Model(preOrder).Where("order_sn = ?", orderSn).First(preOrder).Error; err != nil {
return nil, err
}
return preOrder, nil
}

154
services/binanceservice/futuresbinancerest.go
View File

@ -13,12 +13,10 @@ import (
"go-admin/models/futuresdto"
"go-admin/pkg/httputils"
"go-admin/pkg/utility"
"go-admin/pkg/utility/snowflakehelper"
"strconv"
"strings"
"time"
"github.com/jinzhu/copier"
"github.com/shopspring/decimal"
"gorm.io/gorm"
@ -722,11 +720,10 @@ func (e FutRestApi) ClosePosition(symbol string, orderSn string, quantity decima
判断合约触发
*/
func JudgeFuturesPrice(tradeSet models.TradeSet) {
preOrderVal, _ := helper.DefaultRedis.GetAllList(rediskey.PreFutOrderList)
preOrderVal, _ := helper.DefaultRedis.GetAllList(fmt.Sprintf(rediskey.PreFutOrderList, global.EXCHANGE_BINANCE))
db := GetDBConnection()
if len(preOrderVal) == 0 {
// log.Debug("没有合约预下单")
return
}
futApi := FutRestApi{}
@ -766,32 +763,21 @@ func futTriggerOrder(db *gorm.DB, v *dto.PreOrderRedisList, item string, futApi
return
} else if ok {
defer lock.Release()
key := fmt.Sprintf(rediskey.PreFutOrderList, global.EXCHANGE_BINANCE)
preOrder := DbModels.LinePreOrder{}
key := fmt.Sprintf(rediskey.UserHolding, v.ApiId)
symbols, err := helper.DefaultRedis.GetAllList(key)
if err != nil && err != redis.Nil {
log.Error("获取用户持仓失败", err)
return
}
if err := db.Where("id = ?", v.Id).First(&preOrder).Error; err != nil {
log.Error("获取预下单失败", err)
if errors.Is(err, gorm.ErrRecordNotFound) {
log.Error("不存在待触发主单", item)
helper.DefaultRedis.LRem(rediskey.PreFutOrderList, item)
helper.DefaultRedis.LRem(key, item)
}
return
}
coin := utility.ReplaceSuffix(v.Symbol, preOrder.QuoteSymbol, "")
if utility.ContainsStr(symbols, coin) {
log.Info("用户已经持有", coin)
return
}
hasrecord, _ := helper.DefaultRedis.IsElementInList(rediskey.PreFutOrderList, item)
hasrecord, _ := helper.DefaultRedis.IsElementInList(key, item)
if !hasrecord {
log.Debug("预下单缓存中不存在", item)
@ -827,7 +813,7 @@ func futTriggerOrder(db *gorm.DB, v *dto.PreOrderRedisList, item string, futApi
}
if preOrderVal != "" {
if _, err := helper.DefaultRedis.LRem(rediskey.PreFutOrderList, preOrderVal); err != nil {
if _, err := helper.DefaultRedis.LRem(key, preOrderVal); err != nil {
log.Error("删除redis 预下单失败:", err)
}
}
@ -836,7 +822,7 @@ func futTriggerOrder(db *gorm.DB, v *dto.PreOrderRedisList, item string, futApi
}
if preOrderVal != "" {
if _, err := helper.DefaultRedis.LRem(rediskey.PreFutOrderList, preOrderVal); err != nil {
if _, err := helper.DefaultRedis.LRem(key, preOrderVal); err != nil {
log.Error("删除redis 预下单失败:", err)
}
}
@ -845,10 +831,6 @@ func futTriggerOrder(db *gorm.DB, v *dto.PreOrderRedisList, item string, futApi
log.Error("更新预下单状态失败 ordersn:", v.OrderSn, " status:1")
}
if err := helper.DefaultRedis.RPushList(key, coin); err != nil {
log.Error("写入用户持仓失败", v.Symbol)
}
return
} else {
log.Error("获取锁失败")
@ -1010,125 +992,3 @@ func (e FutRestApi) GetFutSymbolLastPrice(targetSymbol string) (lastPrice decima
}
return lastPrice
}
/*
重下止盈单
*/
func (e FutRestApi) reTakeOrder(parentOrderInfo DbModels.LinePreOrder, orm *gorm.DB) {
parentId := parentOrderInfo.Id
if parentOrderInfo.Pid > 0 {
parentId = parentOrderInfo.Pid
}
price, _ := decimal.NewFromString(parentOrderInfo.Price)
num, _ := decimal.NewFromString(parentOrderInfo.Num)
takePrice := decimal.Zero
holdeAKey := fmt.Sprintf(rediskey.HoldeA, parentId)
holdeAVal, _ := helper.DefaultRedis.GetString(holdeAKey)
holdeA := HoldeData{}
if holdeAVal != "" {
sonic.Unmarshal([]byte(holdeAVal), &holdeA)
}
//查询持仓失败
if holdeA.Id == 0 {
log.Error("查询A账号持仓失败")
return
}
takeOrder := DbModels.LinePreOrder{}
if err := orm.Model(&DbModels.LinePreOrder{}).Where("pid =? AND order_type ='3'").First(&takeOrder).Error; err != nil {
log.Error("查询止盈单失败", err)
return
}
apiUserInfo, _ := GetApiInfo(takeOrder.ApiId)
if apiUserInfo.Id == 0 {
log.Error("重下止盈 查询api信息失败")
return
}
newTakeOrder := DbModels.LinePreOrder{}
copier.Copy(&newTakeOrder, &takeOrder)
newTakeOrder.Id = 0
newTakeOrder.OrderType = 1
newTakeOrder.Status = 0
newTakeOrder.OrderSn = strconv.FormatInt(snowflakehelper.GetOrderId(), 10)
//加仓次数大于0 就需要使用均价
if holdeA.PositionIncrementCount > 0 {
price = holdeA.AveragePrice
}
if parentOrderInfo.Site == "BUY" {
takePrice = price.Mul(decimal.NewFromInt(100).Add(parentOrderInfo.ProfitRate)).Div(decimal.NewFromInt(100))
} else {
takePrice = price.Mul(decimal.NewFromInt(100).Sub(parentOrderInfo.ProfitRate)).Div(decimal.NewFromInt(100))
}
tradeset, _ := GetTradeSet(takeOrder.Symbol, 1)
if tradeset.Coin == "" {
log.Error("查询交易对失败")
return
}
newTakeOrder.Price = takePrice.Truncate(int32(tradeset.PriceDigit)).String()
newTakeOrder.Num = num.Mul(decimal.NewFromFloat(0.995)).Truncate(int32(tradeset.AmountDigit)).String()
if err := orm.Create(&newTakeOrder).Error; err != nil {
log.Error("重新止盈单创建失败", err)
return
}
params := FutOrderPlace{
ApiId: newTakeOrder.ApiId,
Symbol: newTakeOrder.Symbol,
Price: utility.StringToDecimal(newTakeOrder.Price),
Quantity: utility.StringToDecimal(newTakeOrder.Num),
Side: newTakeOrder.Site,
OrderType: "TAKE_PROFIT_MARKET",
Profit: utility.StringToDecimal(newTakeOrder.Price),
NewClientOrderId: newTakeOrder.OrderSn,
}
if err := e.CancelFutOrder(apiUserInfo, takeOrder.Symbol, takeOrder.OrderSn); err != nil {
log.Error("取消老止盈单失败:", err)
orm.Model(&newTakeOrder).Updates(map[string]interface{}{"status": "2", "desc": "取消老止盈单失败," + err.Error()})
return
} else {
if err := orm.Model(&DbModels.LinePreOrder{}).Where("pid = ? AND order_type =5 AND status in ('0','1','5') AND order_sn !=?", parentId, newTakeOrder.OrderSn).Update("status", "4").Error; err != nil {
log.Error("更新旧止盈单取消状态失败 err:", err)
}
}
var err error
for x := 0; x < 3; x++ {
err = e.OrderPlace(orm, params)
if err == nil {
break
}
log.Error("下止盈单失败 第", utility.IntToString(x), "次", " err:", err)
time.Sleep(2 * time.Second * time.Duration(x))
}
if err != nil {
log.Error("重新下单止盈失败 err:", err)
if err1 := orm.Model(&DbModels.LinePreOrder{}).Where("id =?", newTakeOrder.Id).
Updates(map[string]interface{}{"status": "2", "desc": err.Error()}).Error; err1 != nil {
log.Error("重新下单止盈 修改止盈订单失败 id:", newTakeOrder.Id, " takePrice:", takePrice, " err:", err1)
}
}
//修改止盈单信息
if err := orm.Model(&DbModels.LinePreOrder{}).Where("id =?", newTakeOrder.Id).
Updates(map[string]interface{}{"price": takePrice, "rate": parentOrderInfo.ProfitRate}).Error; err != nil {
log.Error("重新下单止盈 修改订单失败 id:", newTakeOrder.Id, " takePrice:", takePrice, " rate:", parentOrderInfo.ProfitRate, " err:", err)
}
}

333
services/binanceservice/futuresrest.go
View File

@ -2,13 +2,24 @@ 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"
"strings"
"time"
"github.com/bytedance/sonic"
"github.com/go-admin-team/go-admin-core/logger"
"github.com/shopspring/decimal"
"gorm.io/gorm"
)
/*
@ -56,7 +67,327 @@ func ChangeFutureOrder(mapData map[string]interface{}) {
logger.Error("订单回调失败,没有状态:", string(mapStr))
return
}
// 更新订单状态
orderStatus, reason := parseOrderStatus(status, mapData)
//todo
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 == 2 && orderStatus == 6:
handleStopLoss(db, preOrder)
//平仓成交
case preOrder.OrderType == 3 && orderStatus == 6:
handleClosePosition(db, preOrder)
}
}
// 平仓单成交
func handleClosePosition(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
panic("unimplemented")
}
// 止损单成交
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
}
// 检查订单类型
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
}
// 获取交易对配置
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
}
// 检查对冲单购买金额
if order.HedgeBuyTotal.Cmp(decimal.Zero) <= 0 {
logger.Errorf("止损单成交 对冲单购买金额为0 订单号:%s", order.OrderSn)
return
}
// 获取系统设置
setting, err := GetSystemSetting(db)
if err != nil {
logger.Errorf("止损单成交 获取系统设置失败 订单号:%s err:%v", order.OrderSn, err)
return
}
// 获取API信息
apiInfo, err := GetChildApiInfo(order.ApiId)
if err != nil {
logger.Errorf("止损单成交 获取api信息失败 订单号:%s err:%v", order.OrderSn, err)
return
}
// 计算价格
price := utility.StrToDecimal(preOrder.Price).Truncate(int32(tradeSet.PriceDigit))
if order.CoverType == 2 {
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
}
// 创建对冲订单
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
}
// 调用API下单
if err := placeFutOrder(db, hedgeOrder, price, &apiInfo); err != nil {
logger.Errorf("主单止损 重下对冲失败，止损单号：%s err:%v", order.OrderSn, err)
}
}
// 创建对冲订单
func createHedgeOrders(order DbModels.LinePreOrder, price decimal.Decimal, tradeSet *models2.TradeSet, apiInfo *DbModels.LineApiUser, setting *DbModels.LineSystemSetting) (DbModels.LinePreOrder, DbModels.LinePreOrder, DbModels.LinePreOrder) {
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: order.HedgeBuyTotal.String(),
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)
}
} 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)
}
}
}
// 主单成交 处理止盈止损订单
// preOrder 主单
func handleFutMainOrderFilled(db *gorm.DB, preOrder *models.LinePreOrder) {
orders := []models.LinePreOrder{}
if err := db.Model(&DbModels.LinePreOrder{}).Where("pid = ? AND order_category = 1 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 == "" {
logger.Error("获取交易对失败")
return
}
for i, order := range orders {
if i >= 2 { // 最多处理 2 个订单
break
}
num = num.Truncate(int32(tradeSet.AmountDigit))
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(order)
}
}
}
// 处理止盈订单
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_LIMIT",
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
}
}
}
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(order models.LinePreOrder) error {
price := utility.StrToDecimal(order.Price)
stopLoss := dto.StopLossRedisList{
Id: order.Id,
PId: order.Pid,
ApiId: order.ApiId,
OrderTye: order.OrderType,
OrderCategory: order.OrderCategory,
Price: price,
SymbolType: order.SymbolType,
Symbol: order.Symbol,
Site: order.Site,
}
stoplossVal, _ := sonic.MarshalString(&stopLoss)
stoplossKey := fmt.Sprintf(rediskey.FuturesStopLossList, global.EXCHANGE_BINANCE)
if stoplossVal == "" {
return errors.New("stoplossVal is empty")
}
if err := helper.DefaultRedis.RPushList(stoplossKey, stoplossVal); err != nil {
return err
}
return nil
}

239
services/binanceservice/spotreset.go
View File

@ -2,10 +2,13 @@ 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"
"go-admin/pkg/utility"
"strconv"
@ -59,7 +62,7 @@ func ChangeSpotOrder(mapData map[string]interface{}) {
}
// 更新订单状态
orderStatus, reason := parseOrderStatus(preOrder, status, mapData)
orderStatus, reason := parseOrderStatus(status, mapData)
if orderStatus == 0 {
logger.Error("订单回调失败,状态错误:", orderSn, " status:", status, " reason:", reason)
@ -99,43 +102,100 @@ func logMapData(mapData map[string]interface{}) {
func handleOrderByType(db *gorm.DB, preOrder *DbModels.LinePreOrder, orderStatus int) {
switch {
// 主单成交
case preOrder.OrderType == 0 && (orderStatus == 9 || orderStatus == 6):
case preOrder.OrderType == 0 && orderStatus == 6:
handleMainOrderFilled(db, preOrder)
//主单取消
case preOrder.OrderType == 0 && preOrder.Pid == 0 && orderStatus == 4:
coin := utility.ReplaceSuffix(preOrder.Symbol, preOrder.QuoteSymbol, "")
removeHoldingCache(preOrder.ApiId, coin, preOrder.Id)
handleMainOrderCancel(preOrder)
// 止盈成交
case preOrder.OrderType == 1 && (orderStatus == 9 || orderStatus == 6):
case preOrder.OrderType == 1 && orderStatus == 6:
handleSpotTakeProfitFilled(db, preOrder)
//主单平仓
case preOrder.OrderType == 3 && orderStatus == 9:
//平仓单
case preOrder.OrderType == 3 && orderStatus == 6:
handleMainOrderClosePosition(db, preOrder)
//主单止损回调
case preOrder.OrderType == 2 && preOrder.OrderCategory == 1 && orderStatus == 6:
if preOrder.CoverType == 0 {
if err := db.Model(&DbModels.LinePreOrder{}).Where("id =?", preOrder.Pid).Update("status", 9).Error; err != nil {
logger.Errorf("主单止损回调 订单号:%s 修改主单状态失败:%v", preOrder.OrderSn, err)
}
}
}
}
// 主单取消
func handleMainOrderCancel(preOrder *DbModels.LinePreOrder) {
preOrderKey := fmt.Sprintf(rediskey.PreSpotOrderList, global.EXCHANGE_BINANCE)
preSpotOrders, _ := helper.DefaultRedis.GetAllList(preOrderKey)
preOrderCache := DbModels.LinePreOrder{}
for _, v := range preSpotOrders {
if v == "" {
continue
}
sonic.Unmarshal([]byte(v), &preOrderCache)
if preOrderCache.Pid == preOrder.Id {
_, err := helper.DefaultRedis.LRem(preOrderKey, v)
if err != nil {
logger.Errorf("订单回调失败, 回调订单号：%s 删除缓存失败:%v", preOrder.OrderSn, err)
}
}
}
}
// 平仓单
func handleMainOrderClosePosition(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
panic("unimplemented")
//主单平仓
if preOrder.OrderCategory == 1 {
if err := db.Model(&DbModels.LinePreOrder{}).Where("id =?", preOrder.Pid).Update("status", 9).Error; err != nil {
logger.Errorf("平仓订单回调失败, 回调订单号：%s 更新主单失败:%v", preOrder.OrderSn, err)
}
} else {
//对冲单回调
if err := db.Model(&DbModels.LinePreOrder{}).
Where("pid =? AND order_category =? AND order_type =0 AND status <9 ", preOrder.Pid, preOrder.OrderCategory).
Update("status", 9).Error; err != nil {
logger.Errorf("对冲单平仓回调失败, 回调订单号：%s 更新对冲单失败:%v", preOrder.OrderSn, err)
}
}
}
// 止盈成交
func handleSpotTakeProfitFilled(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
panic("unimplemented")
}
func removeHoldingCache(i1 int, coin string, i2 int) {
panic("unimplemented")
if err := db.Model(&DbModels.LinePreOrder{}).Where("id =? AND order_category =?", preOrder.Pid, preOrder.OrderCategory).Update("status", 9).Error; err != nil {
logger.Errorf("止盈订单回调失败, 回调订单号：%s 更新主单失败:%v", preOrder.OrderSn, err)
}
stoplossKey := fmt.Sprintf(rediskey.SpotStopLossList, global.EXCHANGE_BINANCE)
stoplossVal, _ := helper.DefaultRedis.GetAllList(stoplossKey)
stoploss := DbModels.LinePreOrder{}
for _, v := range stoplossVal {
sonic.Unmarshal([]byte(v), &stoploss)
if stoploss.Pid == preOrder.Id {
_, err := helper.DefaultRedis.LRem(stoplossKey, v)
if err != nil {
logger.Errorf("订单回调失败, 回调订单号：%s 删除缓存失败:%v", preOrder.OrderSn, err)
}
}
}
}
// 主单成交
func handleMainOrderFilled(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
panic("unimplemented")
processTakeProfitAndStopLossOrders(db, preOrder)
}
// 解析订单状态
// 5:委托中 9:完全成交 4:取消
func parseOrderStatus(preOrder *DbModels.LinePreOrder, status interface{}, mapData map[string]interface{}) (int, string) {
// 5:委托中 6:完全成交 4:取消 9:已平仓
func parseOrderStatus(status interface{}, mapData map[string]interface{}) (int, string) {
reason, _ := mapData["r"].(string)
if strings.ToLower(reason) == "none" {
@ -146,11 +206,7 @@ func parseOrderStatus(preOrder *DbModels.LinePreOrder, status interface{}, mapDa
case "NEW": // 未成交
return 5, reason
case "FILLED": // 完全成交
if preOrder.OrderType < 3 {
return 6, reason
}
return 9, reason
return 6, reason
case "CANCELED", "EXPIRED": // 取消
return 4, reason
default:
@ -179,6 +235,7 @@ func updateOrderStatus(db *gorm.DB, preOrder *models.LinePreOrder, status int, r
params["num"] = num
params["price"] = total.Div(totalAmount)
preOrder.Num = num.String()
preOrder.Price = params["price"].(string)
}
case false:
status, _ := mapData["X"].(string)
@ -189,6 +246,7 @@ func updateOrderStatus(db *gorm.DB, preOrder *models.LinePreOrder, status int, r
params["price"], _ = mapData["ap"].(string)
preOrder.Num = num.String()
preOrder.Price = params["price"].(string)
}
}
@ -197,26 +255,32 @@ func updateOrderStatus(db *gorm.DB, preOrder *models.LinePreOrder, status int, r
}
// 主单成交 处理止盈止损订单
// preOrder 主单
func processTakeProfitAndStopLossOrders(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 {
if err := db.Model(&DbModels.LinePreOrder{}).Where("pid = ? AND order_category = 1 AND order_type > 0 AND status = '0' ", preOrder.Id).Find(&orders).Error; err != nil {
logger.Error("订单回调查询止盈止损单失败:", err)
return
}
spotApi := SpotRestApi{}
num, _ := decimal.NewFromString(preOrder.Num)
num = num.Mul(decimal.NewFromFloat(0.998))
for i, order := range orders {
if i >= 2 { // 最多处理 2 个订单
break
}
if err := db.Model(&order).Update("num", num).Error; err != nil {
logger.Errorf("修改止盈止损数量失败 订单号:%s err:%v", order.OrderSn, err)
}
switch order.OrderType {
case 1: // 止盈
processTakeProfitOrder(db, spotApi, order, num)
case 2: // 止损
processStopLossOrder(db, order)
processStopLossOrder(order)
}
}
}
@ -231,7 +295,6 @@ func processTakeProfitOrder(db *gorm.DB, spotApi SpotRestApi, order models.LineP
}
price, _ := decimal.NewFromString(order.Price)
// num, _ := decimal.NewFromString(order.Num)
params := OrderPlacementService{
ApiId: order.ApiId,
@ -264,7 +327,7 @@ func processTakeProfitOrder(db *gorm.DB, spotApi SpotRestApi, order models.LineP
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()}).Error; err != nil {
Updates(map[string]interface{}{"status": "2", "desc": err.Error(), "num": params.Quantity}).Error; err != nil {
logger.Error("现货止盈下单失败,更新状态失败:", order.OrderSn, " err:", err)
}
} else {
@ -277,110 +340,32 @@ func processTakeProfitOrder(db *gorm.DB, spotApi SpotRestApi, order models.LineP
// 处理止损订单
// order 止损单
func processStopLossOrder(db *gorm.DB, order models.LinePreOrder) error {
// var stopOrder models.LinePreOrder
// orderTypes := []string{"4", "6", "9", "12"}
// parentId := order.Id
// if order.Pid > 0 {
// parentId = order.Pid
// }
// if utility.ContainsStr(orderTypes, order.OrderType) {
// var err error
// stopOrder, err = GetStopOrder(db, order.Pid)
// if err != nil {
// logger.Error("查询止损单失败:", err)
// return err
// }
// }
// price, _ := decimal.NewFromString(stopOrder.Price)
// stoploss, _ := decimal.NewFromString(order.Rate)
// if holdeB.Id > 0 {
// _, holdeA := GetHoldeA(stopOrder.Pid)
// var percent decimal.Decimal
// lastPercent, _ := GetStopOrderRate(db, stopOrder.Pid)
// if stopOrder.Site == "BUY" {
// //平仓次数>=最大次数 且余数为0 重新计算触发对冲百分比
// // if holdeA.Id > 0 && holdeB.HedgeCloseCount >= stopOrder.HedgeCloseCount && (holdeB.HedgeCloseCount%stopOrder.HedgeCloseCount == 0) {
// rand := getRand(stopOrder.HedgeTriggerPercent, stopOrder.HedgeTriggerPercentMax, lastPercent, 1)
// percent = decimal.NewFromInt(100).Add(rand).Div(decimal.NewFromInt(100))
// // } else {
// // rate, _ := decimal.NewFromString(stopOrder.Rate)
// // percent = decimal.NewFromInt(100).Add(rate).Div(decimal.NewFromInt(100))
// // }
// } else {
// // if holdeA.Id > 0 && holdeB.HedgeCloseCount >= stopOrder.HedgeCloseCount {
// rand := getRand(stopOrder.HedgeTriggerPercent, stopOrder.HedgeTriggerPercentMax, lastPercent, 1)
// percent = decimal.NewFromInt(100).Sub(rand).Div(decimal.NewFromInt(100))
// // } else {
// // rate, _ := decimal.NewFromString(stopOrder.Rate)
// // percent = decimal.NewFromInt(100).Sub(rate).Div(decimal.NewFromInt(100))
// // }
// }
// stoploss = decimal.NewFromInt(100).Sub(percent.Mul(decimal.NewFromInt(100))).Truncate(2)
// price = holdeA.AveragePrice.Mul(percent)
// }
// tradeset, _ := GetTradeSet(stopOrder.Symbol, 1)
// if tradeset.PriceDigit > 0 {
// price = price.Truncate(int32(tradeset.PriceDigit))
// }
// cache := dto.StopLossRedisList{
// PId: stopOrder.Pid,
// ApiId: stopOrder.ApiId,
// Price: price,
// OrderTye: stopOrder.OrderType,
// Site: stopOrder.Site,
// Symbol: stopOrder.Symbol,
// Stoploss: stoploss,
// }
// stoplossKey := fmt.Sprintf(rediskey.SpotStopLossList)
// cacheVal, _ := sonic.MarshalString(&cache)
// if stopOrder.OrderType == "4" {
// stoplossKey = rediskey.FuturesStopLossList
// }
// stopLossVal, _ := helper.DefaultRedis.GetAllList(stoplossKey)
// for _, itemVal := range stopLossVal {
// if strings.Contains(itemVal, fmt.Sprintf("\"pid\":%v,", stopOrder.Pid)) {
// helper.DefaultRedis.LRem(stoplossKey, itemVal)
// break
// }
// }
// //重新保存待触发对冲单
// if err := helper.DefaultRedis.RPushList(stoplossKey, cacheVal); err != nil {
// logger.Error("B单平仓回调,redis添加止损单失败", err)
// }
return nil
}
// 生成随机数 且不重复
// lastPercent 上一次的百分比
// floatNum 小数点后几位
func getRand(start, end, lastPercent decimal.Decimal, floatNum int) decimal.Decimal {
var rand decimal.Decimal
for x := 0; x < 10; x++ {
rand = utility.DecimalRandom(start, end, floatNum)
if rand.Cmp(lastPercent) != 0 {
break
}
func processStopLossOrder(order models.LinePreOrder) error {
price := utility.StrToDecimal(order.Price)
stopLoss := dto.StopLossRedisList{
Id: order.Id,
PId: order.Pid,
ApiId: order.ApiId,
OrderTye: order.OrderType,
OrderCategory: order.OrderCategory,
Price: price,
SymbolType: order.SymbolType,
Symbol: order.Symbol,
Site: order.Site,
}
return rand
stoplossVal, _ := sonic.MarshalString(&stopLoss)
stoplossKey := fmt.Sprintf(rediskey.SpotStopLossList, global.EXCHANGE_BINANCE)
if stoplossVal == "" {
return errors.New("stoplossVal is empty")
}
if err := helper.DefaultRedis.RPushList(stoplossKey, stoplossVal); err != nil {
return err
}
return nil
}
func GetSystemSetting(db *gorm.DB) (models.LineSystemSetting, error) {