package data import ( "context" "encoding/json" "github.com/go-xorm/xorm" "github.com/shopspring/decimal" "matchmaking-system/internal/biz/structure" "matchmaking-system/internal/data/socket/publicData" "matchmaking-system/internal/data/tradedeal/virtual" "matchmaking-system/internal/pkg/flags" "matchmaking-system/internal/pkg/logging/applogger" "matchmaking-system/internal/pkg/logging/common" "matchmaking-system/internal/pkg/setting" "matchmaking-system/internal/pkg/utils" "strconv" "strings" orders "matchmaking-system/internal/data/convert" models "matchmaking-system/internal/pkg/model" ) // GetBotContractTradeList // // @Description: 合约-秒合约订单列表查询 // @receiver uo // @param ctx // @param pageSize // @param pageCount // @param userId // @param status // @return []*models.BotContractTrade // @return int64 // @return error func (uo *userOrderRepo) GetBotContractTradeList(ctx context.Context, pageSize, pageCount, userId, status int64) ([]*models.BotContractTrade, int64, error) { totalCount, err := uo.data.mysqlDB.Table(flags.BotContractTrade). Where("user_id = ?", userId). Where("status = ?", status). Count() if err != nil { return nil, 0, flags.ErrMySqlDB } if totalCount == 0 { return nil, 0, nil } var contractList []*models.BotContractTrade if err = uo.data.mysqlDB.Table(flags.BotContractTrade). Where("user_id = ?", userId). Where("status = ?", status). Limit(int(pageSize), int(pageCount)). Desc(GetOrderByStatusSort(status)). Find(&contractList); err != nil { return nil, 0, flags.ErrMySqlDB } var contractUpdateList []*models.BotContractTrade for _, value := range contractList { value.KeepDecimal = GetKeepDecimal(flags.ContractSystemSetUpKey, value.ContractId) contractUpdateList = append(contractUpdateList, value) } return contractUpdateList, totalCount, nil } // CreateBotContractTrade // // @Description: 合约下单 // @receiver uo // @param ctx // @param userId // @param order // @return string // @return error func (uo *userOrderRepo) CreateBotContractTrade(ctx context.Context, userId int64, order structure.ContractOrder) (string, error) { // 1、合约下单订阅 contractId := strings.ToUpper(order.ContractId) _, ok := contract.ContractMapSymbol.Load(contractId) if ok { go func() { contract.ContractMap <- []byte(contractId) }() } // 2、获取系统设置 system, err := GetContractSystemSetUp(contractId) if err != nil || system == nil { return flags.SetNull, flags.ErrContractOne } order.System = system // 3、获取交易币市价 //priceNew, err := GetDigitalCurrencyPrice(ctx, flags.Hy, contractId) //if len(priceNew) == 0 || err != nil { // applogger.Error("%v CreateBotContractTrade.ContractSubMarketPrice:%v", common.ErrContract, err) // return flags.SetNull, flags.ErrPriceUpdate //} // 4、合约下单判定 // 杠杆校验 pryNum := decimal.RequireFromString(order.PryNum) if pryNum.Cmp(order.System.MinPry) < 0 || pryNum.Cmp(order.System.MaxPry) > 0 { return flags.SetNull, flags.ErrContractTow } // 下单判定设置(false无设置|true止盈止损) checkBool, stopWinPrice, stopLossPrice, err := ContractVoteStopType(order) if err != nil { applogger.Error("%v CreateBotContractTrade.ContractVoteStopType:%v", common.ErrContract, err) return flags.SetNull, err } // 下单判定设置(限价|市价) limitOrMarketPrice, err := uo.ContractVoteDealType(order) if err != nil { applogger.Error("%v CreateBotContractTrade.ContractVoteDealType:%v", common.ErrContract, err) return flags.SetNull, err } // 下单判定设置(买涨|买跌) if err = uo.VoteTradeType(order.TradeType, stopWinPrice, stopLossPrice, limitOrMarketPrice, checkBool); err != nil { applogger.Error("%v CreateBotContractTrade.VoteTradeType:%v", common.ErrContract, err) return flags.SetNull, err } // 5、合约下单(订单信息|资产信息) orderId, err := uo.ContractOrdersWriteDB(ctx, userId, order) if err != nil || len(orderId) == 0 { applogger.Error("%v CreateBotContractTrade.ContractOrdersWriteDB:%v", common.ErrContract, err) return flags.SetNull, err } // 6、写入缓存列表(挂单缓存|持仓缓存),等待撮合计算 marketStatus, tallyCache, err := virtual.ContractCacheDeal(ctx, userId, orderId, limitOrMarketPrice.String(), order) if err != nil || tallyCache == nil { applogger.Error("%v CreateBotContractTrade.ContractCacheDeal:%v", common.ErrContract, err) return flags.SetNull, err } // 7、市价下单开仓处理(订单信息|资产信息|手续费|返佣|资产详情记录) if marketStatus == setting.MarketContractPosition { if err = ContractOpenPosition(ctx, uo.data.mysqlDB, userId, orderId, tallyCache.OpenPrice, order); err != nil { applogger.Error("%v CreateBotContractTrade.ContractOpenPosition:%v", common.ErrContract, err) return flags.SetNull, err } } // 8、写入(挂单|持仓)缓存列表 if err = virtual.ContractPushAddCache(Reds, marketStatus, tallyCache); err != nil { applogger.Error("%v CreateBotContractTrade.ContractPushAddCache:%v", common.ErrContract, err) return flags.SetNull, flags.ErrCacheDB } // 9、写入用户订单订阅缓存列表 orderIdKey := virtual.OrderIdListKey(setting.ContractSubscribe, userId) if err = virtual.ContractHashSetOrderId(Reds, orderIdKey, tallyCache); err != nil { applogger.Error("%v CreateBotContractTrade.ContractPushAddOrder:%v", common.ErrContract, err) return flags.SetNull, flags.ErrCacheDB } // 10、写入管理员订单订阅缓存列表 if err = virtual.ContractHashSetOrderId(Reds, setting.AdminContractSubscribe, tallyCache); err != nil { applogger.Error("%v CreateBotContractTrade.ContractHashSetOrderId:%v", common.ErrContract, err) return flags.SetNull, flags.ErrCacheDB } return orderId, nil } // ContractOrdersWriteDB // // @Description: 合约下单处理 // @receiver uo // @param ctx // @param userId // @param order // @return string // @return error func (uo *userOrderRepo) ContractOrdersWriteDB(ctx context.Context, userId int64, order structure.ContractOrder) (string, error) { session := uo.data.mysqlDB.NewSession() defer session.Close() err := session.Begin() if err != nil { applogger.Error("%v ContractOrdersWriteDB.NewSession:%v", common.ErrContract, err) return flags.SetNull, flags.ErrMySqlDB } // 查询当前下单用户可用账户金额和冻结金额 var usable, frozen, usableNo, frozenNo decimal.Decimal usable, frozen, _, err = uo.GetBotUserContract(session, userId, flags.BasicUnit) if err != nil { applogger.Error("%v ContractOrdersWriteDB.GetBotUserContract:%v", common.ErrContract, err) return flags.SetNull, flags.ErrMySqlDB } // 检查用户订单下单资产 if usable.IsZero() || usable.IsNegative() || frozen.IsNegative() { return flags.SetNull, flags.ErrPublicOne } // 查询当前下单用户可用非账户和冻结金额 var checkCount int if order.ContractId != flags.BasicUnit { usableNo, frozenNo, checkCount, err = uo.GetBotUserContract(session, userId, order.ContractId) if err != nil { applogger.Error("%v ContractOrdersWriteDB.GetBotUserContract.Fei:%v", common.ErrContract, err) return flags.SetNull, flags.ErrMySqlDB } } if !flags.CheckSetting { applogger.Debug("下单可用金额:%v", usable) applogger.Debug("下单冻结金额:%v", frozen) applogger.Debug("非下单可用金额:%v", usableNo) applogger.Debug("非下单冻结金额:%v", frozenNo) } // 写入订单信息 orderId, err := uo.VerifyBotContractTradeOrderId(session) if err != nil { applogger.Error("%v ContractOrdersWriteDB.VerifyBotContractTradeOrderId:%v", common.ErrContract, err) return flags.SetNull, err } if !flags.CheckSetting { applogger.Debug("下单Id:%v", orderId) applogger.Debug("杠杆:%v", order.PryNum) } // 写入订单表 botStockTrade := orders.BotContractTrade(ctx, userId, orderId, order) if err = uo.CreatBotContractTrade(session, botStockTrade); err != nil { applogger.Error("%v ContractOrdersWriteDB.CreatBotContractTrade:%v", common.ErrContract, err) return flags.SetNull, flags.ErrMySqlDB } // 订单总金额 = 保证金 + 手续费 earnestMoney := decimal.RequireFromString(order.EarnestMoney) // 保证金 serviceCost := decimal.RequireFromString(order.ServiceCost) // 手续费 totalMoney := earnestMoney.Add(serviceCost) // 总金额下单判定 residue := usable.Sub(totalMoney).Div(usable) if usable.Cmp(totalMoney) < 0 || residue.Cmp(utils.DecimalsStrInt()) < 0 { return flags.SetNull, flags.ErrPublicOne } // (买涨|买跌)处理 var usableNew, frozenNew, usableNewNo, frozenNewNo decimal.Decimal usableNew = usable.Sub(totalMoney) // 可用资产 frozenNew = frozen.Add(totalMoney) // 冻结资产 if order.ContractId != flags.BasicUnit { usableNewNo = usableNo // 可用非资产 frozenNewNo = frozenNo // 冻结非资产 } // 检查用户订单下单资产 if usableNew.IsNegative() || usableNew.IsZero() { return flags.SetNull, flags.ErrPublicTow } if !flags.CheckSetting { applogger.Debug("下单后用户可用资产:%v", usableNew) applogger.Debug("下单后用户冻结资产:%v", frozenNew) applogger.Debug("下单后用户非可用资产:%v", usableNewNo) applogger.Debug("下单后用户非冻结资产:%v", frozenNewNo) } // 更新用户资产信息 userContractUSDT := orders.UpdateBotUserContract(ctx, usableNew.String(), frozenNew.String()) if err = uo.UpdateBotUserContract(session, userId, flags.BasicUnit, userContractUSDT); err != nil { applogger.Error("%v ContractOrdersWriteDB.UpdateBotUserContract:%v", common.ErrContract, err) return flags.SetNull, flags.ErrMySqlDB } // 更新非资产信息 if order.ContractId != flags.BasicUnit { if checkCount == 0 { userDigitalSymbol := orders.CreatBotUserContract(ctx, userId, usableNewNo.String(), frozenNewNo.String(), order) err = uo.CreatBotUserContract(session, userDigitalSymbol) if err != nil { applogger.Error("%v ContractOrdersWriteDB.CreatBotUserContract:%v", common.ErrContract, err) return flags.SetNull, flags.ErrMySqlDB } } else { userContract := orders.UpdateBotUserContract(ctx, usableNewNo.String(), frozenNewNo.String()) if err = uo.UpdateBotUserContract(session, userId, order.ContractId, userContract); err != nil { applogger.Error("%v ContractOrdersWriteDB.UpdateBotUserContract:%v", common.ErrContract, err) return flags.SetNull, flags.ErrMySqlDB } } } if err = session.Commit(); err != nil { applogger.Error("%v ContractOrdersWriteDB.Commit:%v", common.ErrContract, err) return flags.SetNull, flags.ErrMySqlDB } return orderId, nil } // ContractOpenPosition // // @Description: 合约开仓处理 // @param ctx // @param db // @param userId // @param orderId // @param openPrice // @param order // @return error func ContractOpenPosition(ctx context.Context, db *xorm.EngineGroup, userId int64, orderId, openPrice string, order structure.ContractOrder) error { session := db.NewSession() defer session.Close() err := session.Begin() if err != nil { applogger.Error("%v ContractOpenPosition.NewSession:%v", common.ErrContract, err) return flags.ErrMySqlDB } // 查询当前下单用户可用账户金额和冻结金额 var usable, frozen, usableNo, frozenNo decimal.Decimal usable, frozen, _, err = Uo.GetBotUserContract(session, userId, flags.BasicUnit) if err != nil { applogger.Error("%v ContractOpenPosition.GetBotUserContract:%v", common.ErrContract, err) return flags.ErrMySqlDB } if usable.IsNegative() || frozen.IsNegative() { return flags.ErrPublicThree } if !flags.CheckSetting { applogger.Debug("下单可用金额:%v", usable) applogger.Debug("下单冻结金额:%v", frozen) } if order.ContractId != flags.BasicUnit { usableNo, frozenNo, _, err = Uo.GetBotUserContract(session, userId, order.ContractId) if err != nil { applogger.Error("%v ContractOpenPosition.GetBotUserContract:%v", common.ErrContract, err) return flags.ErrMySqlDB } } // 转换下单信息 earnestMoney := decimal.RequireFromString(order.EarnestMoney) // 下单保证金 orderNumber := decimal.RequireFromString(order.OrderNumber) // 下单仓位 serviceCost := decimal.RequireFromString(order.ServiceCost) // 下单手续费 totalMoney := earnestMoney.Add(serviceCost) // 下单总金额 = (订单手续费 + 保证金) openOrderPrice := decimal.RequireFromString(openPrice) // 开仓价格 openOrderNumber := orderNumber // 开仓数量 if !flags.CheckSetting { applogger.Debug("下单保证金:%v", earnestMoney) applogger.Debug("下单订单数量:%v", orderNumber) applogger.Debug("下单订单手续费:%v", serviceCost) applogger.Debug("下单订单总金额:%v", totalMoney) applogger.Debug("下单开仓量:%v", openOrderNumber) applogger.Debug("下单开仓价:%v", openOrderPrice) } //openFaceValue := order.System.FaceValue // 面值 //openOrderPrice := decimal.RequireFromString(openPrice) // 开仓价格 //pryNum := decimal.RequireFromString(order.PryNum) // 杠杆 //openOrderNumber := orderNumber // 开仓数量 //openOrderNumber := earnestMoney.Mul(pryNum).Div(openOrderPrice).Div(openFaceValue) // 开仓数量 = (保证金 * 杠杆) / 开仓价格 / 面值 // TODO: 手续费记录 //openPriceNew := openOrderPrice.Mul(openOrderNumber).String() // 开仓手续费 = 开仓价格 * 仓位数 * 手续费比例 //cost, err := Uo.CalculateHandlingFees(ctx, session, int(userId), flags.ContractMarketType, flags.OpenBrokType, orderId, openPriceNew, openFaceValue.String()) //if err != nil { // applogger.Error("%v ContractOpenPosition.CalculateHandlingFees:%v", common.ErrContract, err) // return err //} //openServiceCost := decimal.RequireFromString(cost) // 开仓手续费 openServiceCost := serviceCost //开仓手续费 openTotalMoney := earnestMoney.Add(openServiceCost) // 开仓总金额 = (保证金 + 开仓手续费) floatPrice := totalMoney.Sub(openTotalMoney) // 计算容差 = 下单总额 - 开仓总额 if !flags.CheckSetting { applogger.Debug("开仓订单价格:%v", openOrderPrice) applogger.Debug("开仓仓位:%v", openOrderNumber) applogger.Debug("开仓手续费:%v", openServiceCost) applogger.Debug("开仓总金额:%v", openTotalMoney) applogger.Debug("下单开仓总金额容差值:%v", floatPrice) } usableNew := usable.Add(floatPrice) // 可用资产(处理容差值) frozenNew := frozen.Sub(totalMoney).Add(earnestMoney) // 冻结资产 = 冻结资产 - 下单冻结资产 + 开仓保证金 usableNoNew := usableNo.Add(openOrderNumber) // 非可用资产 frozenNoNew := frozenNo // 非冻结资产 if !flags.CheckSetting { applogger.Debug("下单后用户可用资产:%v", usableNew) applogger.Debug("下单后用户冻结资产:%v", frozenNew) } applogger.Debug("下单冻结资产:%v", frozen) applogger.Debug("下单后的冻结总资产:%v", totalMoney) applogger.Debug("开仓后的保证金:%v", earnestMoney) applogger.Debug("下单后用户冻结资产:%v", frozenNew) applogger.Debug("下单后用户可用资产:%v", usableNew) // 检查用户平仓资产 if usableNoNew.IsNegative() { return flags.ErrPublicThree } // 处理资产信息 userContractUSDT := orders.UpdateBotUserContract(ctx, usableNew.String(), frozenNew.String()) if err = Uo.UpdateBotUserContract(session, userId, flags.BasicUnit, userContractUSDT); err != nil { applogger.Error("%v ContractOpenPosition.UpdateBotUserContract:%v", common.ErrContract, err) return flags.ErrMySqlDB } // 更新非资产信息 if order.ContractId != flags.BasicUnit { userContract := orders.UpdateBotUserContract(ctx, usableNoNew.String(), frozenNoNew.String()) if err = Uo.UpdateBotUserContract(session, userId, order.ContractId, userContract); err != nil { applogger.Error("%v ContractOpenPosition.UpdateBotUserContract:%v", common.ErrContract, err) return flags.ErrMySqlDB } } // 处理订单信息(成交价|仓位|开仓时间|订单总金额|手续费|持仓状态) trade := orders.UpdateOpenBotContractTrade(ctx, openPrice, openOrderNumber.String(), openTotalMoney.String(), openServiceCost.String()) if err = Uo.UpdateBotContractTradeByOrderId(session, orderId, trade); err != nil { applogger.Error("%v ContractOpenPosition.UpdateBotContractTradeByOrderId:%v", common.ErrContract, err) return flags.ErrMySqlDB } // 返佣记录|资金信息|资金详情信息 if err = Uo.ContractRebateCalculation(ctx, session, int(userId), flags.ContractMarketType, flags.OpenBrokType, flags.OpenMRebate, openServiceCost.String(), orderId); err != nil { applogger.Error("%v ContractOpenPosition.ContractRebateCalculation:%v", common.ErrContract, err) return flags.ErrMySqlDB } // 更改交易日志记录方式 var list []models.BotUserContractLog qData0 := orders.CreatBotUserContractLog(ctx, userId, flags.CostMoney, flags.BasicUnit, NegativeValue(openServiceCost.String()), orderId) // 资金变动明细表(开仓手续费) qData1 := orders.CreatBotUserContractLog(ctx, userId, flags.Freeze, flags.BasicUnit, NegativeValue(earnestMoney.String()), orderId) // 资金变动明细表(开仓保证金) qData2 := orders.CreatBotUserContractLog(ctx, userId, flags.ChangeInto, order.ContractId, orderNumber.String(), orderId) // 资金变动明细表(非资产) list = append(list, qData0, qData1, qData2) // 批量写入数据信息 if err = Uo.CreatBotUserContractLogList(session, list); err != nil { applogger.Error("%v ContractOpenPosition.CreatBotUserContractLogList:%v", common.ErrContract, err) return flags.ErrMySqlDB } if err = session.Commit(); err != nil { applogger.Error("%v ContractOpenPosition.Commit:%v", common.ErrContract, err) return flags.ErrMySqlDB } return nil } // ContractClosingPosition // // @Description: 合约平仓处理 // @param ctx // @param db // @param orderId // @param price // @param order // @return error func ContractClosingPosition(ctx context.Context, db *xorm.EngineGroup, orderId string, price string, order structure.ContractOrder) error { session := db.NewSession() defer session.Close() err := session.Begin() if err != nil { applogger.Error("%v ContractClosingPosition.NewSession:%v", common.ErrContract, err) return flags.ErrMySqlDB } // 查询订单信息 tread, err := Uo.GetBotContractTradeByOrderId(session, orderId, flags.PositionStatus) if err != nil { applogger.Error("%v ContractClosingPosition.GetBotContractTradeByOrderId:%v", common.ErrContract, err) return flags.ErrMySqlDB } var userId int64 var dealPrice, earnestMoney, orderNumber, totalAmount, serviceCost, pryNum decimal.Decimal if tread != nil { userId = int64(tread.UserId) // 用户Id earnestMoney = decimal.RequireFromString(tread.EarnestMoney) // 开仓保证金 orderNumber = decimal.RequireFromString(tread.OrderNumber) // 下单数量 dealPrice = decimal.RequireFromString(tread.DealPrice) // 开仓价格 totalAmount = decimal.RequireFromString(tread.TotalMoney) // 开仓总金额 serviceCost = decimal.RequireFromString(tread.ServiceCost) // 开仓手续费 pryNum = decimal.RequireFromString(strconv.Itoa(tread.PryNum)) // 杠杆 } if !flags.CheckSetting { applogger.Debug("下单开仓用户Id:%v", userId) applogger.Debug("下单开仓开仓价格:%v", dealPrice) applogger.Debug("下单开仓保证金:%v", earnestMoney) applogger.Debug("下单开仓订单数量:%v", orderNumber) applogger.Debug("下单开仓总金额:%v", totalAmount) applogger.Debug("下单开仓手续费:%v", serviceCost) applogger.Debug("下单杠杆:%v", pryNum) } // 查询当前下单用户可用账户金额和冻结金额 var usable, frozen, usableNo, frozenNo decimal.Decimal usable, frozen, _, err = Uo.GetBotUserContract(session, userId, flags.BasicUnit) if err != nil { applogger.Error("%v ContractClosingPosition.GetBotUserContract:%v", common.ErrContract, err) return flags.ErrMySqlDB } // 检查用户订单平仓资产 if usable.IsNegative() || frozen.IsNegative() { return flags.ErrContractFive } if !flags.CheckSetting { applogger.Debug("下单可用金额:%v", usable) applogger.Debug("下单冻结金额:%v", frozen) } // 查询当前下单用户可用非账户和冻结金额 if order.ContractId != flags.BasicUnit { usableNo, frozenNo, _, err = Uo.GetBotUserContract(session, userId, order.ContractId) if err != nil { applogger.Error("%vContractClosingPosition.GetBotUserContract:%v", common.ErrContract, err) return flags.ErrMySqlDB } } if !flags.CheckSetting { applogger.Debug("非下单可用金额:%v", usableNo) applogger.Debug("非下单冻结金额:%v", frozenNo) } closeFaceValue := order.System.FaceValue // 面值 // 手续费处理 closePrice := decimal.RequireFromString(price) // 平仓价格 cloePriceCost := closePrice.Mul(orderNumber).String() // 平仓手续费 = 平仓价格 * 仓位数 * 手续费比例 * 面值 cost, err := Uo.CalculateHandlingFees(ctx, session, int(userId), flags.ContractMarketType, flags.ClosingBrokType, orderId, cloePriceCost, closeFaceValue.String()) if err != nil { applogger.Error("%v ContractClosingPosition.CalculateHandlingFees:%v", common.ErrContract, err) return err } closeServiceCost := decimal.RequireFromString(cost) if !flags.CheckSetting { applogger.Debug("平仓价格:%v", closePrice) applogger.Debug("平仓手续费手续费:%v", closeServiceCost) } //已经实现盈亏计算公式(已平仓结算方式) //买涨 已经实现盈亏 = (平仓成交价-开仓成交价)*仓位数*面值*杠杆 //买跌 已经实现盈亏 = (开仓成交价-平仓成交价)*仓位数*面值*杠杆 var usableNew, frozenNew, usableNewNo, frozenNewNo, subPrice, resultPrice decimal.Decimal switch order.TradeType { case flags.TradeTypeBuy: // 买涨 subPrice = closePrice.Sub(dealPrice) resultPrice = subPrice.Mul(orderNumber).Mul(closeFaceValue).Mul(pryNum) case flags.TradeTypeSell: // 买跌 subPrice = dealPrice.Sub(closePrice) resultPrice = subPrice.Mul(orderNumber).Mul(closeFaceValue).Mul(pryNum) default: } // TODO: 判定亏损不能超过 = 保证金 + 平仓手续费 if resultPrice.IsNegative() { amountLoss := earnestMoney.Sub(closeServiceCost) if resultPrice.Abs().Cmp(amountLoss) >= 0 { resultPrice = amountLoss.Neg() } } // 用户资产账户 usableNew = usable.Add(resultPrice).Add(earnestMoney).Sub(closeServiceCost) // 可用资产 = 原可用资产 + ((正负)盈亏*面值) + 保证金 - 手续费 frozenNew = frozen.Sub(earnestMoney) // 冻结资产 if frozenNew.IsNegative() { frozenNew = decimal.Zero } // 用户非资产账户 if order.ContractId != flags.BasicUnit { usableNewNo = usableNo.Sub(orderNumber) // 可用非资产 = 原可用非资产 - 下单仓位数 frozenNewNo = frozenNo // 可用非冻结资产 } // 检查用户订单平仓资产 if usableNewNo.IsNegative() { return flags.ErrContractFive } if !flags.CheckSetting { applogger.Debug("可用资产:%v", usableNew) applogger.Debug("冻结资产:%v", frozenNew) applogger.Debug("可用非资产:%v", usableNewNo) applogger.Debug("冻结非资产:%v", frozenNewNo) } // 平仓(处理资产表(资产)) userContractUSDT := orders.UpdateBotUserContract(ctx, usableNew.String(), frozenNew.String()) if err = Uo.UpdateBotUserContract(session, userId, flags.BasicUnit, userContractUSDT); err != nil { applogger.Error("%v ContractClosingPosition.UpdateBotUserContract:%v", common.ErrContract, err) return flags.ErrMySqlDB } // 平仓(处理资产表(非资产)) if order.ContractId != flags.BasicUnit { userContract := orders.UpdateBotUserContract(ctx, usableNewNo.String(), frozenNewNo.String()) if err = Uo.UpdateBotUserContract(session, userId, order.ContractId, userContract); err != nil { applogger.Error("%v ContractClosingPosition.UpdateBotUserContract:%v", common.ErrContract, err) return flags.ErrMySqlDB } } // 平仓(处理订单信息(平仓价|保证金|平仓|订单总金额|平仓手续费|完成订单)) trade := orders.UpdateCloseBotContractTrade(ctx, price, earnestMoney.String(), totalAmount.String(), cost) if err = Uo.UpdateBotContractTradeByOrderId(session, orderId, trade); err != nil { applogger.Error("%v ContractClosingPosition.UpdateBotContractTradeByOrderId:%v", common.ErrContract, err) return flags.ErrMySqlDB } // 平仓(返佣记录表|资产表|资金变动表) if err = Uo.ContractRebateCalculation(ctx, session, int(userId), flags.ContractMarketType, flags.ClosingBrokType, flags.CloseMRebate, cost, orderId); err != nil { applogger.Error("%v ContractClosingPosition.ContractRebateCalculation:%v", common.ErrContract, err) return flags.ErrMySqlDB } // 更改交易日志记录方式 var list []models.BotUserContractLog qData0 := orders.CreatBotUserContractLog(ctx, userId, flags.CostMoney, flags.BasicUnit, NegativeValue(closeServiceCost.String()), orderId) // 平仓(资金变动明细表(-平仓手续费)) qData1 := orders.CreatBotUserContractLog(ctx, userId, flags.Thaw, flags.BasicUnit, earnestMoney.String(), orderId) // 平仓(资金变动明细表(+保证金)) qData2 := orders.CreatBotUserContractLog(ctx, userId, flags.TransferOut, order.ContractId, NegativeValue(orderNumber.String()), orderId) // 平仓(资金变动明细表(-非资产)) list = append(list, qData0, qData1, qData2) // 平仓(资金变动明细表(正负盈亏)) if resultPrice.IsNegative() { qData3 := orders.CreatBotUserContractLog(ctx, userId, flags.TransferOut, flags.BasicUnit, resultPrice.String(), orderId) list = append(list, qData3) } else { qData4 := orders.CreatBotUserContractLog(ctx, userId, flags.ChangeInto, flags.BasicUnit, resultPrice.String(), orderId) list = append(list, qData4) } // 平仓(批量写入交易订单日志信息) if err = Uo.CreatBotUserContractLogList(session, list); err != nil { applogger.Error("%v ContractClosingPosition.CreatBotUserContractLogList:%v", common.ErrContract, err) return flags.ErrMySqlDB } if err = session.Commit(); err != nil { applogger.Error("%v ContractClosingPosition.Commit:%v", common.ErrContract, err) return flags.ErrMySqlDB } return nil } // UpdateBotContractStopByOrderId // // @Description: 合约设置止盈止损 // @receiver uo // @param ctx // @param order // @return bool // @return error func (uo *userOrderRepo) UpdateBotContractStopByOrderId(ctx context.Context, order structure.StopOrder) (bool, error) { session := uo.data.mysqlDB.NewSession() defer session.Close() err := session.Begin() if err != nil { applogger.Error("%v UpdateBotContractStopByOrderId.NewSession:%v", common.ErrContract, err) return false, flags.ErrMySqlDB } // 设置止盈止损判定 trade, err := uo.GetBotContractTradeByOrderId(session, order.OrderId, flags.PositionStatus) if err != nil || trade == nil { applogger.Error("%v UpdateBotContractStopByOrderId.GetBotContractTradeByOrderId:%v", common.ErrContract, err) return false, flags.ErrMySqlDB } // 下单信息 checkBool, stopWinPrice, stopLossPrice, err := uo.UpdateVoteStopType(order) if err != nil { applogger.Error("%v UpdateBotContractStopByOrderId.UpdateVoteStopType:%v", common.ErrContract, err) return false, err } if !flags.CheckSetting { applogger.Debug("获取当前止盈止损数据:%v,%v,%v", checkBool, stopWinPrice, stopLossPrice) } // 下单判定设置(限价|市价|开仓价) limitOrMarketPrice, err := uo.UpdateVoteDealType(trade) if err != nil { applogger.Error("%v UpdateBotContractStopByOrderId.UpdateVoteDealType:%v", common.ErrContract, err) return false, err } if !flags.CheckSetting { applogger.Debug("获取当前开仓价格:%v", limitOrMarketPrice) } // 下单判定设置(买涨|买跌) if err = uo.VoteTradeType(int64(trade.TradeType), stopWinPrice, stopLossPrice, limitOrMarketPrice, checkBool); err != nil { applogger.Error("%v UpdateBotContractStopByOrderId.VoteTradeType:%v", common.ErrContract, err) return false, err } // 更新订单表 botStockTrade := orders.BotContractStopByOrderId(ctx, order) err = uo.UpdateBotContractTradeByOrderId(session, order.OrderId, botStockTrade) if err != nil { applogger.Error("%v UpdateBotContractStopByOrderId.Update:%v", common.ErrContract, err) return false, flags.ErrMySqlDB } // 修改挂单缓存队列 entrust, err := LoadLRangeList(setting.MarketContractPosition) if err != nil { applogger.Error("%v UpdateBotContractStopByOrderId.LoadLRangeList:%v", common.ErrContract, err) return false, flags.ErrCacheDB } for key, value := range entrust { var entrustJson virtual.ContractTallyCache if err = json.Unmarshal([]byte(value), &entrustJson); err != nil { applogger.Error("%v UpdateBotContractStopByOrderId.Unmarshal:%v", common.ErrContract, err) return false, flags.ErrCacheDB } entrustJson.Order.StopType = order.StopType entrustJson.Order.StopWinPrice = order.StopWinPrice entrustJson.Order.StopLossPrice = order.StopLossPrice if !flags.CheckSetting { applogger.Debug("修改缓存中的止盈止损Type:%v", entrustJson.Order.StopType) applogger.Debug("修改缓存中的止盈:%v", entrustJson.Order.StopWinPrice) applogger.Debug("修改缓存中的止损:%v", entrustJson.Order.StopLossPrice) } var data []byte data, err = json.Marshal(&entrustJson) if err != nil { applogger.Error("%v UpdateBotContractStopByOrderId.Marshal:%v", common.ErrContract, err) return false, flags.ErrCacheDB } if order.OrderId == entrustJson.OrderId { if err = Reds.HSet(context.Background(), setting.MarketContractPosition, key, string(data)).Err(); err != nil { applogger.Error("%v UpdateBotContractStopByOrderId.HSet:%v", common.ErrContract, err) return false, flags.ErrCacheDB } } } if err = session.Commit(); err != nil { applogger.Error("%v UpdateBotContractStopByOrderId.Commit:%v", common.ErrContract, err) return false, flags.ErrMySqlDB } return true, nil } // UpdateBotContractCancelByOrderId // // @Description: 合约撤单 // @receiver uo // @param ctx // @param orderId // @return bool // @return error func (uo *userOrderRepo) UpdateBotContractCancelByOrderId(ctx context.Context, orderId string) (bool, error) { session := uo.data.mysqlDB.NewSession() defer session.Close() err := session.Begin() if err != nil { applogger.Error("%v UpdateBotContractCancelByOrderId.NewSession:%v", common.ErrContract, err) return false, flags.ErrMySqlDB } // get BotContractTrade tread, err := uo.GetBotContractTradeByOrderId(session, orderId, flags.EntrustStatus) if err != nil { applogger.Error("%v UpdateBotContractCancelByOrderId.GetBotContractTradeByOrderId:%v", common.ErrContract, err) return false, flags.ErrMySqlDB } var userId int64 var earnestMoneyT, serviceCostT, symbol, orderNumber string if tread != nil { userId = int64(tread.UserId) earnestMoneyT = tread.EarnestMoney serviceCostT = tread.ServiceCost orderNumber = tread.OrderNumber symbol, err = uo.GetSymbol(tread.ContractId) if err != nil { applogger.Error("%v UpdateBotContractCancelByOrderId.GetSymbol:%v", common.ErrContract, err) return false, flags.ErrMySqlDB } } // get BotUserStock By USD var usable, frozen, usableNo, frozenNo decimal.Decimal usable, frozen, _, err = uo.GetBotUserContract(session, userId, flags.BasicUnit) if err != nil { applogger.Error("%v UpdateBotContractCancelByOrderId.GetBotUserContract:%v", common.ErrContract, err) return false, flags.ErrMySqlDB } // 检查用户订单撤单资产 if frozen.IsNegative() || usable.IsNegative() { return false, flags.ErrPublicFour } if !flags.CheckSetting { applogger.Debug("用户原始可用资金:%v", usable) applogger.Debug("用户原始冻结资金:%v", frozen) } if symbol != flags.BasicUnit { usableNo, frozenNo, _, err = uo.GetBotUserContract(session, userId, tread.ContractId) if err != nil { applogger.Error("%v UpdateBotContractCancelByOrderId.GetBotUserContract:%v", common.ErrContract, err) return false, flags.ErrPublicFour } } if !flags.CheckSetting { applogger.Debug("用户原始可用非资金:%v", usableNo) applogger.Debug("用户原始冻结非资金:%v", frozenNo) } // 更新订单信息 botStockTrade := orders.BotContractCancelByOrderId(ctx) if err = uo.UpdateBotContractTradeByOrderId(session, orderId, botStockTrade); err != nil { applogger.Error("%v UpdateBotContractCancelByOrderId.UpdateBotContractTradeByOrderId:%v", common.ErrContract, err) return false, flags.ErrPublicFour } // Operational Spot Asset Table earnestMoney := decimal.RequireFromString(earnestMoneyT) // 保证金 serviceCost := decimal.RequireFromString(serviceCostT) // 订单手续费 totalMoney := earnestMoney.Add(serviceCost) // 订单总金额 if !flags.CheckSetting { applogger.Debug("撤单用户ID:%v", userId) applogger.Debug("下单交易对:%v", symbol) applogger.Debug("撤单订单保证金:%v", earnestMoneyT) applogger.Debug("撤单手续费:%v", serviceCostT) applogger.Debug("撤单订单数量:%v", orderNumber) applogger.Debug("撤单总金额数量:%v", totalMoney) } // Update total asset data usableNew := usable.Add(totalMoney) // 用户总资产 frozenNew := frozen.Sub(totalMoney) // 用户冻结资产 usableNoNew := usableNo // 用户非可用资产 frozenNoNew := frozenNo // 用户非冻结资产 // 检查用户订单撤单资产 if frozenNew.IsNegative() { return false, flags.ErrContractSeven } if !flags.CheckSetting { applogger.Debug("用户撤单可用总资产:%v", usableNew) applogger.Debug("用户撤单冻结总资产:%v", frozenNew) applogger.Debug("用户非撤单可用总资产:%v", usableNoNew) applogger.Debug("用户非撤单冻结总资产:%v", frozenNoNew) } userContractUSDT := orders.UpdateBotUserContract(ctx, usableNew.String(), frozenNew.String()) if err = uo.UpdateBotUserContract(session, userId, flags.BasicUnit, userContractUSDT); err != nil { applogger.Error("%v UpdateBotContractCancelByOrderId.UpdateBotUserContract:%v", common.ErrContract, err) return false, flags.ErrMySqlDB } if symbol != flags.BasicUnit { userContract := orders.UpdateBotUserContract(ctx, usableNoNew.String(), frozenNoNew.String()) if err = uo.UpdateBotUserContract(session, userId, tread.ContractId, userContract); err != nil { applogger.Error("%v UpdateBotContractCancelByOrderId.UpdateBotUserContract:%v", common.ErrContract, err) return false, flags.ErrMySqlDB } } // 清理挂单缓存信息 if err = Reds.HDel(context.Background(), setting.MarketContractEntrust, orderId).Err(); err != nil { applogger.Error("%v UpdateBotContractCancelByOrderId.HDel:%v", common.ErrContract, err) return false, flags.ErrCacheDB } // 撤单更新订阅缓存订单状态 userSubKey := virtual.OrderIdListKey(setting.ContractSubscribe, userId) if err = UpdateContractSubscribeHashStatusByOrderId(orderId, userSubKey, flags.Cancel, flags.SetNull); err != nil { applogger.Error("%v UpdateBotContractCancelByOrderId.ContractSubscribe:%v", common.ErrContract, err) return false, flags.ErrCacheDB } // 撤单更新管理员订阅缓存订单状态 if err = UpdateContractSubscribeHashStatusByOrderId(orderId, setting.AdminContractSubscribe, flags.Cancel, flags.SetNull); err != nil { applogger.Error("%v UpdateBotContractCancelByOrderId.AdminContractSubscribe:%v", common.ErrContract, err) return false, flags.ErrCacheDB } if err = session.Commit(); err != nil { applogger.Error("%v UpdateBotContractCancelByOrderId.Commit:%v", common.ErrContract, err) return false, flags.ErrMySqlDB } return true, nil } // UpdateBotContractClosingByOrderId // // @Description: 合约平仓 // @receiver uo // @param ctx // @param orderId // @return bool // @return error func (uo *userOrderRepo) UpdateBotContractClosingByOrderId(ctx context.Context, orderId string) (bool, error) { // 1、订单信息 entrust, err := Reds.HGet(context.Background(), setting.MarketContractPosition, orderId).Result() if err != nil { applogger.Error("%v UpdateBotContractClosingByOrderId.MarketContractPosition.HGet:%v", common.ErrContract, err) return false, flags.ErrMySqlDB } var entrustJson virtual.ContractTallyCache if err = json.Unmarshal([]byte(entrust), &entrustJson); err != nil { applogger.Error("%v UpdateBotContractClosingByOrderId.Unmarshal:%v", common.ErrContract, err) return false, flags.ErrCacheDB } if !flags.CheckSetting { applogger.Debug("手动平仓:%v", entrustJson) } // 2、当前最新价格 var openPrice decimal.Decimal subKey := publicData.SymbolCache(flags.Hy, entrustJson.Symbol, flags.TradeTypePrice) openPrice, err = uo.GetTheLatestPrice(ctx, subKey, entrustJson.Order.TradeType) if err != nil { return false, flags.ErrContractEight } if err = Reds.HDel(context.Background(), setting.MarketContractPosition, orderId).Err(); err != nil { applogger.Error("%v UpdateBotContractClosingByOrderId.MarketContractPosition.HDel:%v", common.ErrContract, err) return false, flags.ErrCacheDB } // 3、平仓处理 if err = ContractClosingPosition(ctx, uo.data.mysqlDB, orderId, openPrice.String(), entrustJson.Order); err != nil { applogger.Error("%v UpdateBotContractClosingByOrderId.ContractClosingPosition:%v", common.ErrContract, err) return false, flags.ErrCacheDB } // 4、平仓更新订阅缓存订单状态 userSubKey := virtual.OrderIdListKey(setting.ContractSubscribe, entrustJson.UserId) if err = UpdateContractSubscribeHashStatusByOrderId(orderId, userSubKey, flags.Close, flags.SetNull); err != nil { applogger.Error("%v UpdateBotContractClosingByOrderId.ContractSubscribe:%v", common.ErrContract, err) return false, flags.ErrCacheDB } // 5、平仓更新管理员订阅缓存订单状态 if err = UpdateContractSubscribeHashStatusByOrderId(orderId, setting.AdminContractSubscribe, flags.Close, flags.SetNull); err != nil { applogger.Error("%v UpdateBotContractCancelByOrderId.AdminContractSubscribe:%v", common.ErrContract, err) return false, flags.ErrCacheDB } return true, nil } // UpdateBotContractClosingAllByOrderId // // @Description: 合约一键平仓 // @receiver uo // @param ctx // @param userId // @return error func (uo *userOrderRepo) UpdateBotContractClosingAllByOrderId(ctx context.Context, userId int64) error { // 1、查询当前用户所有订单 orderMap, err := uo.GetBotContractTradeByUserId(userId) if err != nil { applogger.Error("%v UpdateBotContractClosingAllByOrderId.GetBotContractTradeByUserId:%v", common.ErrContract, err) return flags.ErrMySqlDB } // 2、查询持仓缓存列表数据-1>清理持仓列表缓存 2>处理平仓数据 3>清理订单ID缓存列表 for _, value := range orderMap { var entrust string entrust, err = Reds.HGet(context.Background(), setting.MarketContractPosition, value).Result() if err != nil { applogger.Error("%v UpdateBotContractClosingAllByOrderId.MarketContractPosition.LRange:%v", common.ErrContract, err) return flags.ErrCacheDB } var entrustJson virtual.ContractTallyCache if err = json.Unmarshal([]byte(entrust), &entrustJson); err != nil { applogger.Error("%v UpdateBotContractClosingAllByOrderId.Unmarshal:%v", common.ErrContract, err) return flags.ErrCacheDB } // 当前市价 var openPrice decimal.Decimal subKey := publicData.SymbolCache(flags.Hy, entrustJson.Symbol, flags.TradeTypePrice) openPrice, err = uo.GetTheLatestPrice(ctx, subKey, entrustJson.Order.TradeType) if err != nil { applogger.Error("%v UpdateBotContractClosingAllByOrderId.GetTheLatestPrice:%v", common.ErrContract, err) return flags.ErrMySqlDB } if !flags.CheckSetting { applogger.Debug("订阅Key:%v,最新价格:%v,订单ID:%v", subKey, openPrice, entrustJson.OrderId) } // 清理持仓缓存列表 if err = Reds.HDel(context.Background(), setting.MarketContractPosition, value).Err(); err != nil { applogger.Error("%v UpdateBotContractClosingAllByOrderId.MarketContractPosition.HDel:%v", common.ErrContract, err) return flags.ErrCacheDB } // 平仓 if err = ContractClosingPosition(ctx, uo.data.mysqlDB, entrustJson.OrderId, openPrice.String(), entrustJson.Order); err != nil { applogger.Error("%v UpdateBotContractClosingAllByOrderId.ContractClosingPosition:%v", common.ErrContract, err) return err } // 平仓更新用户订阅订单状态 userSubKey := virtual.OrderIdListKey(setting.ContractSubscribe, entrustJson.UserId) if err = UpdateContractSubscribeHashStatusByOrderId(entrustJson.OrderId, userSubKey, flags.Close, flags.SetNull); err != nil { applogger.Error("%v UpdateBotContractClosingAllByOrderId.ContractSubscribe:%v", common.ErrContract, err) return flags.ErrMySqlDB } // 平仓更新管理员订阅订单状态 if err = UpdateContractSubscribeHashStatusByOrderId(entrustJson.OrderId, setting.AdminContractSubscribe, flags.Close, flags.SetNull); err != nil { applogger.Error("%v UpdateBotContractCancelByOrderId.AdminContractSubscribe:%v", common.ErrContract, err) return flags.ErrMySqlDB } } return nil } // GetBotContractTradeByOrderId // // @Description: // @receiver uo // @param ctx // @param session // @param orderId // @param status // @return *models.BotContractTrade // @return error func (uo *userOrderRepo) GetBotContractTradeByOrderId(session *xorm.Session, orderId string, status int) (*models.BotContractTrade, error) { var botContractTrade []models.BotContractTrade if err := session.Table(flags.BotContractTrade). Where("order_id = ?", orderId). Where("`status` = ?", status). Find(&botContractTrade); err != nil { return nil, err } for _, value := range botContractTrade { return &value, nil } return nil, nil } // GetBotContractTradeByUserId // // @Description: // @receiver uo // @param ctx // @param userId // @return map[string]string // @return error func (uo *userOrderRepo) GetBotContractTradeByUserId(userId int64) (map[string]string, error) { var botContractTrade []models.BotContractTrade if err := uo.data.mysqlDB.Table(flags.BotContractTrade). Where("user_id = ? ", userId). Where("status = 1"). Find(&botContractTrade); err != nil { return nil, err } botMap := make(map[string]string) for _, value := range botContractTrade { botMap[value.OrderId] = value.OrderId } return botMap, nil } // GetBotUserContract // // @Description: // @receiver uo // @param ctx // @param session // @param userId // @param symbol // @return decimal.Decimal // @return decimal.Decimal // @return int // @return error func (uo *userOrderRepo) GetBotUserContract(session *xorm.Session, userId int64, symbol string) (decimal.Decimal, decimal.Decimal, int, error) { var contractUSDT []models.BotUserContract if err := session.Table(flags.BotUserContract). Where("user_id = ?", userId). Where("contract_id = ?", strings.ToUpper(symbol)). Find(&contractUSDT); err != nil { return decimal.Zero, decimal.Zero, 0, err } var usableNum, frozenNum decimal.Decimal for _, value := range contractUSDT { usableNum = decimal.RequireFromString(value.UsableNum) // 资产可用余额 frozenNum = decimal.RequireFromString(value.FrozenNum) // 资产冻结数量 } return usableNum, frozenNum, len(contractUSDT), nil } // ContractVoteDealType // // @Description: // @receiver uo // @param ctx // @param order // @return decimal.Decimal // @return error func (uo *userOrderRepo) ContractVoteDealType(order structure.ContractOrder) (decimal.Decimal, error) { var limitOrMarketPrice decimal.Decimal switch order.DealType { case flags.DealTypeLimited: // 限价 if len(order.LimitPrice) != 0 { limitOrMarketPrice = decimal.RequireFromString(order.LimitPrice) } case flags.DealTypeMarket: // 市价 if len(order.MarketPrice) != 0 { limitOrMarketPrice = decimal.RequireFromString(order.MarketPrice) } default: return decimal.Decimal{}, flags.ErrPublicFive } return limitOrMarketPrice, nil } // UpdateVoteDealType // // @Description: // @receiver uo // @param ctx // @param order // @return decimal.Decimal // @return error func (uo *userOrderRepo) UpdateVoteDealType(order *models.BotContractTrade) (decimal.Decimal, error) { var limitOrMarketPrice decimal.Decimal switch order.DealType { case flags.DealTypeLimited: // 限价 if len(order.LimitPrice) != 0 { limitOrMarketPrice = decimal.RequireFromString(order.LimitPrice) } case flags.DealTypeMarket: // 市价 if len(order.MarketPrice) != 0 { limitOrMarketPrice = decimal.RequireFromString(order.MarketPrice) } default: return decimal.Decimal{}, flags.ErrPublicFive } if len(order.DealPrice) != 0 { dealPrice := decimal.RequireFromString(order.DealPrice) if !dealPrice.IsZero() { limitOrMarketPrice = dealPrice } } return limitOrMarketPrice, nil } // UpdateVoteStopType // // @Description: // @receiver uo // @param ctx // @param order // @return bool // @return decimal.Decimal // @return decimal.Decimal // @return error func (uo *userOrderRepo) UpdateVoteStopType(order structure.StopOrder) (bool, decimal.Decimal, decimal.Decimal, error) { var checkBool bool var stopWinPrice, stopLossPrice decimal.Decimal switch order.StopType { case flags.StopTypeNone: // 暂无设置止盈止损 checkBool = false case flags.StopTypeSet: // 设置止盈止损 if len(order.StopWinPrice) != 0 { stopWinPrice = decimal.RequireFromString(order.StopWinPrice) } if len(order.StopLossPrice) != 0 { stopLossPrice = decimal.RequireFromString(order.StopLossPrice) } // 判定设置是否都为零 if stopWinPrice.IsZero() && stopLossPrice.IsZero() { return checkBool, decimal.Decimal{}, decimal.Decimal{}, flags.ErrContractTen } else { checkBool = true } default: return checkBool, stopWinPrice, stopLossPrice, flags.ErrContractEleven } return checkBool, stopWinPrice, stopLossPrice, nil } // VoteTradeType // // @Description: 股票判定止盈止损配置 // @receiver uo // @param ctx // @param tradeType // @param stopWinPrice // @param stopLossPrice // @param price // @param checkBool // @return error func (uo *userOrderRepo) VoteTradeType(tradeType int64, stopWinPrice, stopLossPrice, price decimal.Decimal, checkBool bool) error { if checkBool { switch tradeType { case flags.TradeTypeBuy: // 买涨 if !stopWinPrice.IsZero() { if stopWinPrice.Cmp(price) <= 0 { // 限价买涨下单,止盈价格必须大于限价 return flags.ErrBuyStopWinPrice } } if !stopLossPrice.IsZero() { if stopLossPrice.Cmp(price) >= 0 { // 限价买涨下单,止损价格必须小于限价 return flags.ErrBuyStopLossPrice } } case flags.TradeTypeSell: // 买跌 if !stopWinPrice.IsZero() { if stopWinPrice.Cmp(price) >= 0 { // 限价买跌下单,止盈价格必须小于限价 return flags.ErrSellStopWinPrice } } if !stopLossPrice.IsZero() { if stopLossPrice.Cmp(price) <= 0 { // 限价买跌下单,止损价格必须大于限价 return flags.ErrSellStopLossPrice } } default: return flags.ErrContractTwelve } } return nil } // VoteTradeTypeOption // // @Description: 期权判定止盈止损配置 // @receiver uo // @param dealType 市价|限价 // @param tradeType 看涨(calls-CE)|看跌(puts-PE) // @param tradingType 买入(buy)|卖出(sell) // @param stopWinPrice 止盈价格 // @param stopLossPrice 止损价格 // @param limitOrMarketPrice 设置价格(市价|限价) // @param bid 买一价 // @param ask 卖一价 // @param checkBool // @return error func (uo *userOrderRepo) VoteTradeTypeOption(dealType, tradeType, tradingType int64, stopWinPrice, stopLossPrice, limitOrMarketPrice, bid, ask decimal.Decimal, checkBool bool) error { if checkBool { switch dealType { case flags.DealTypeMarket: // 市价 switch tradeType { case flags.OptionCalls: // call-(buy|sell) return StopOrWinCmp(tradingType, ask, bid, stopWinPrice, stopLossPrice, limitOrMarketPrice, false) case flags.OptionPuts: // put-(buy|sell) return StopOrWinCmp(tradingType, ask, bid, stopWinPrice, stopLossPrice, limitOrMarketPrice, false) default: return flags.ErrContractTwelve } case flags.DealTypeLimited: // 限价 switch tradeType { case flags.TradeTypeBuy: // call-(buy|sell) return StopOrWinCmp(tradingType, ask, bid, stopWinPrice, stopLossPrice, limitOrMarketPrice, true) case flags.TradeTypeSell: // put-(buy|sell) return StopOrWinCmp(tradingType, ask, bid, stopWinPrice, stopLossPrice, limitOrMarketPrice, true) default: return flags.ErrContractTwelve } default: return flags.ErrContractTwelve } } return nil } // StopOrWinCmp // // @Description: // @param tradingType // @param ask // @param bid // @param stopWinPrice // @param stopLossPrice // @return error func StopOrWinCmp(tradingType int64, ask, bid, stopWinPrice, stopLossPrice, limitOrMarketPrice decimal.Decimal, check bool) error { /** 期权下单止盈止损判定 一、call-buy 和 put-buy 限价开仓价格 < 卖一价 止盈价 > 买一价 止损价 < 卖一价 二、call-sell 和 put-sell 限价单开仓价格 > 买一价 止盈价 < 卖一价 止损价 > 买一价 */ switch tradingType { case flags.OptionBuy: // buy if !stopWinPrice.IsZero() { if stopWinPrice.Cmp(bid) > 0 { return flags.ErrBuyStopWinPriceOption // 看涨下单,止盈价大于买一价 } } if !stopLossPrice.IsZero() { if stopLossPrice.Cmp(ask) < 0 { return flags.ErrBuyStopLossPriceOption // 看涨下单,止损价小于卖一价 } } if check { // limit order start if limitOrMarketPrice.Cmp(ask) < 0 { return flags.ErrBuyLimitPriceOption // 看涨下单,开仓价格小于卖一价 } } case flags.OptionSell: // sell if !stopWinPrice.IsZero() { if stopWinPrice.Cmp(ask) < 0 { return flags.ErrSellStopWinPriceOption // 看跌下单,止盈价小于卖一价 } } if !stopLossPrice.IsZero() { if stopLossPrice.Cmp(bid) > 0 { return flags.ErrSellStopLossPriceOption // 看跌下单,止损价大于买一价 } } if check { // limit order start if limitOrMarketPrice.Cmp(bid) > 0 { return flags.ErrSellLimitPriceOption // 看跌下单,开仓价格大于买一价 } } default: return flags.ErrContractTwelve } return nil } // CreatBotUserContract // // @Description: // @receiver uo // @param ctx // @param session // @param digital // @return error func (uo *userOrderRepo) CreatBotUserContract(session *xorm.Session, digital models.BotUserContract) error { _, err := session.Table(flags.BotUserContract).Insert(&digital) if err != nil { return err } return nil } // CreatBotContractTrade // // @Description: // @receiver uo // @param ctx // @param session // @param trade // @return error func (uo *userOrderRepo) CreatBotContractTrade(session *xorm.Session, trade models.BotContractTrade) error { _, err := session.Table(flags.BotContractTrade).Insert(&trade) if err != nil { return err } return nil } // UpdateBotContractTradeByOrderId // // @Description: // @receiver uo // @param ctx // @param session // @param orderId // @param trade // @return error func (uo *userOrderRepo) UpdateBotContractTradeByOrderId(session *xorm.Session, orderId string, trade models.BotContractTrade) error { _, err := session.Table(flags.BotContractTrade). Where("order_id = ?", orderId). Update(&trade) if err != nil { return err } return nil } // UpdateBotUserContract // // @Description: // @receiver uo // @param ctx // @param session // @param userId // @param symbol // @param userContract // @return error func (uo *userOrderRepo) UpdateBotUserContract(session *xorm.Session, userId int64, symbol string, userContract models.BotUserContract) error { _, err := session.Table(flags.BotUserContract). Where("user_id = ?", userId). Where("contract_id = ?", symbol). Update(&userContract) if err != nil { return err } return nil } // GetSymbol // // @Description: // @receiver uo // @param ctx // @param contractId // @return string // @return error func (uo *userOrderRepo) GetSymbol(contractId string) (string, error) { var symbol string symbolList := strings.Split(contractId, "-") if len(symbolList) == 2 { symbol = symbolList[0] } else { return "", flags.ErrContractThree } return symbol, nil } // VerifyBotContractTradeOrderId // // @Description: // @receiver uo // @param ctx // @param session // @return string // @return error func (uo *userOrderRepo) VerifyBotContractTradeOrderId(session *xorm.Session) (string, error) { var orderId string for { orderId = orders.CreateRandCodeOrder(10) var orderList []models.BotContractTrade err := session.Table(flags.BotContractTrade).Where("order_id = ?", orderId).Find(&orderList) if err != nil || len(orderList) > 0 { applogger.Error("%v VerifyBotContractTradeOrderId.Find:%v", common.ErrContract, err) continue } break } return orderId, nil } // GetTheLatestPrice // // @Description: // @receiver uo // @param ctx // @param subKey // @param tradeType // @return decimal.Decimal // @return error func (uo *userOrderRepo) GetTheLatestPrice(ctx context.Context, subKey string, tradeType int64) (decimal.Decimal, error) { priceNew, err := virtual.ContractSubMarketPrice(ctx, subKey) if err != nil { applogger.Error("%v GetTheLatestPrice.ContractSubMarketPrice:%v", common.ErrContract, err) return decimal.Decimal{}, err } priceS := decimal.RequireFromString(priceNew) var openPrice decimal.Decimal difference := priceS.Mul(utils.Difference()) // 设置价差 switch tradeType { case flags.TradeTypeBuy: // 买涨 openPrice = priceS.Sub(difference) // 开仓价格 case flags.TradeTypeSell: // 买跌 openPrice = priceS.Add(difference) // 开仓价格 default: } return openPrice, nil }