You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
830 lines
30 KiB
830 lines
30 KiB
package data
|
|
|
|
import (
|
|
"fmt"
|
|
"matchmaking-system/internal/biz/structure"
|
|
"matchmaking-system/internal/data/tradedeal/share"
|
|
"matchmaking-system/internal/pkg/flags"
|
|
"matchmaking-system/internal/pkg/logging/applogger"
|
|
"matchmaking-system/internal/pkg/logging/common"
|
|
"matchmaking-system/internal/pkg/setting"
|
|
"strconv"
|
|
"time"
|
|
|
|
models "matchmaking-system/internal/pkg/model"
|
|
)
|
|
|
|
// RestoreCacheShareUs
|
|
//
|
|
// @Description: 恢复美股|德股|法股|英股|泰股|马股|印尼股|印度股|新加坡股|港股|期权|大宗交易|订单缓存数据
|
|
// @param data
|
|
func RestoreCacheShareUs(data *Data) {
|
|
var stockList []*models.BotStockTrade
|
|
if err := data.mysqlDB.Table(flags.BotStockTrade).
|
|
Where("status in (0,1)").
|
|
Asc("`status`").
|
|
Find(&stockList); err != nil {
|
|
return
|
|
}
|
|
|
|
for _, value := range stockList {
|
|
flatRatio := GetCacheForcedClosure(flags.StockUsSystemSetUpKey, value.StockId) // 设置强平阈值
|
|
leverStatus := SystemShareMarketLeverStatus(flags.StockMarketList, flags.UsMarket, int64(value.UserId)) // 股票市场系统设置
|
|
system := &structure.ShareSystem{
|
|
StrongFlatRatio: flatRatio.String(), // 强平阈值
|
|
Status: leverStatus.Status, // 杠杆状态
|
|
StockMin: leverStatus.StockMin, // 开启杠杆的最小值
|
|
LevelMin: leverStatus.LevelMin, // 杠杆最小值
|
|
LevelMax: leverStatus.LevelMax, // 杠杆最大值
|
|
UserStatus: leverStatus.UserStatus, // 用户开启状态
|
|
}
|
|
closingTime := SystemTimeGenerate(flags.StockMarketList, flags.UsMarket, time.Now()) // 开盘时间
|
|
shareOrder := &share.ShareUsTallyCache{
|
|
UserId: int64(value.UserId),
|
|
OrderId: value.OrderId,
|
|
Symbol: value.StockId,
|
|
Status: strconv.Itoa(value.Status),
|
|
OpenPrice: value.DealPrice,
|
|
ClosingPrice: value.ClosingPrice,
|
|
ClosingTime: closingTime,
|
|
Order: structure.ShareOrder{
|
|
System: system,
|
|
StockId: value.StockId,
|
|
TradeType: int64(value.TradeType),
|
|
DealType: int64(value.DealType),
|
|
LimitPrice: value.LimitPrice,
|
|
MarketPrice: value.MarketPrice,
|
|
MarketMoney: value.MarketMoney,
|
|
OrderNumber: value.OrderNumber,
|
|
ServiceCost: value.ServiceCost,
|
|
StopType: int64(value.StopType),
|
|
StopLossPrice: value.StopLossPrice,
|
|
StopWinPrice: value.StopWinPrice,
|
|
UserId: value.UserId,
|
|
PryNum: strconv.Itoa(value.PryNum),
|
|
},
|
|
}
|
|
|
|
// 订单状态
|
|
var marketStatus string
|
|
switch value.Status {
|
|
case 0:
|
|
marketStatus = setting.MarketShareUsEntrust
|
|
case 1:
|
|
marketStatus = setting.MarketShareUsPosition
|
|
default:
|
|
}
|
|
|
|
// 写入缓存数据(挂单|持仓)
|
|
if err := share.ShareUsHashUserOrder(Reds, marketStatus, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareUs.%v:%v", common.ErrShareUs, marketStatus, err)
|
|
return
|
|
}
|
|
|
|
// 写入用户订阅缓存
|
|
userCacheKey := fmt.Sprintf("%v-%v", setting.ShareUsSubscribe, value.UserId)
|
|
if err := share.ShareUsHashUserOrder(Reds, userCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareUs.%v:%v", common.ErrShareUs, userCacheKey, err)
|
|
return
|
|
}
|
|
|
|
// 写入管理员订阅缓存
|
|
adminCacheKey := setting.AdminShareUsSubscribe
|
|
if err := share.ShareUsHashUserOrder(Reds, adminCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareUs.%v:%v", common.ErrShareUs, adminCacheKey, err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
func RestoreCacheShareEur(data *Data) {
|
|
var stockList []*models.BotStockEurTrade
|
|
if err := data.mysqlDB.Table(flags.BotStockEurTrade).
|
|
Where("status in (0,1)").
|
|
Asc("`status`").
|
|
Find(&stockList); err != nil {
|
|
return
|
|
}
|
|
|
|
for _, value := range stockList {
|
|
flatRatio := GetCacheForcedClosure(flags.StockEURSystemSetUpKey, value.StockId) // 设置强平阈值
|
|
leverStatus := SystemShareMarketLeverStatus(flags.StockMarketList, flags.EurMarket, int64(value.UserId)) // 股票市场系统设置
|
|
system := &structure.ShareSystem{
|
|
StrongFlatRatio: flatRatio.String(), // 强平阈值
|
|
Status: leverStatus.Status, // 杠杆状态
|
|
StockMin: leverStatus.StockMin, // 开启杠杆的最小值
|
|
LevelMin: leverStatus.LevelMin, // 杠杆最小值
|
|
LevelMax: leverStatus.LevelMax, // 杠杆最大值
|
|
UserStatus: leverStatus.UserStatus, // 用户开启状态
|
|
}
|
|
closingTime := SystemTimeGenerate(flags.StockMarketList, flags.EurMarket, time.Now()) // 开盘时间
|
|
shareOrder := &share.ShareEurTallyCache{
|
|
UserId: int64(value.UserId),
|
|
OrderId: value.OrderId,
|
|
Symbol: value.StockId,
|
|
Status: strconv.Itoa(value.Status),
|
|
OpenPrice: value.DealPrice,
|
|
ClosingPrice: value.ClosingPrice,
|
|
ClosingTime: closingTime,
|
|
Order: structure.ShareOrder{
|
|
System: system,
|
|
StockId: value.StockId,
|
|
TradeType: int64(value.TradeType),
|
|
DealType: int64(value.DealType),
|
|
LimitPrice: value.LimitPrice,
|
|
MarketPrice: value.MarketPrice,
|
|
MarketMoney: value.MarketMoney,
|
|
OrderNumber: value.OrderNumber,
|
|
ServiceCost: value.ServiceCost,
|
|
StopType: int64(value.StopType),
|
|
StopLossPrice: value.StopLossPrice,
|
|
StopWinPrice: value.StopWinPrice,
|
|
UserId: value.UserId,
|
|
PryNum: strconv.Itoa(value.PryNum),
|
|
},
|
|
}
|
|
|
|
// 订单状态
|
|
var marketStatus string
|
|
switch value.Status {
|
|
case 0:
|
|
marketStatus = setting.MarketShareEurEntrust
|
|
case 1:
|
|
marketStatus = setting.MarketShareEurPosition
|
|
default:
|
|
}
|
|
|
|
// 写入缓存数据(挂单|持仓)
|
|
if err := share.ShareEurHashUserOrder(Reds, marketStatus, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareEur.%v:%v", common.ErrShareEur, marketStatus, err)
|
|
return
|
|
}
|
|
|
|
// 写入用户订阅缓存
|
|
userCacheKey := fmt.Sprintf("%v-%v", setting.ShareEurSubscribe, value.UserId)
|
|
if err := share.ShareEurHashUserOrder(Reds, userCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareEur.%v:%v", common.ErrShareEur, userCacheKey, err)
|
|
return
|
|
}
|
|
|
|
// 写入管理员订阅缓存
|
|
adminCacheKey := setting.AdminShareEurSubscribe
|
|
if err := share.ShareEurHashUserOrder(Reds, adminCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareEur.%v:%v", common.ErrShareEur, adminCacheKey, err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
func RestoreCacheShareFur(data *Data) {
|
|
var stockList []*models.BotStockFurTrade
|
|
if err := data.mysqlDB.Table(flags.BotStockFurTrade).
|
|
Where("status in (0,1)").
|
|
Asc("`status`").
|
|
Find(&stockList); err != nil {
|
|
return
|
|
}
|
|
|
|
for _, value := range stockList {
|
|
flatRatio := GetCacheForcedClosure(flags.StockFURSystemSetUpKey, value.StockId) // 设置强平阈值
|
|
leverStatus := SystemShareMarketLeverStatus(flags.StockMarketList, flags.FurMarket, int64(value.UserId)) // 股票市场系统设置
|
|
system := &structure.ShareSystem{
|
|
StrongFlatRatio: flatRatio.String(), // 强平阈值
|
|
Status: leverStatus.Status, // 杠杆状态
|
|
StockMin: leverStatus.StockMin, // 开启杠杆的最小值
|
|
LevelMin: leverStatus.LevelMin, // 杠杆最小值
|
|
LevelMax: leverStatus.LevelMax, // 杠杆最大值
|
|
UserStatus: leverStatus.UserStatus, // 用户开启状态
|
|
}
|
|
closingTime := SystemTimeGenerate(flags.StockMarketList, flags.ThaMarket, time.Now()) // 开盘时间
|
|
shareOrder := &share.ShareFurTallyCache{
|
|
UserId: int64(value.UserId),
|
|
OrderId: value.OrderId,
|
|
Symbol: value.StockId,
|
|
Status: strconv.Itoa(value.Status),
|
|
OpenPrice: value.DealPrice,
|
|
ClosingPrice: value.ClosingPrice,
|
|
ClosingTime: closingTime,
|
|
Order: structure.ShareOrder{
|
|
System: system,
|
|
StockId: value.StockId,
|
|
TradeType: int64(value.TradeType),
|
|
DealType: int64(value.DealType),
|
|
LimitPrice: value.LimitPrice,
|
|
MarketPrice: value.MarketPrice,
|
|
MarketMoney: value.MarketMoney,
|
|
OrderNumber: value.OrderNumber,
|
|
ServiceCost: value.ServiceCost,
|
|
StopType: int64(value.StopType),
|
|
StopLossPrice: value.StopLossPrice,
|
|
StopWinPrice: value.StopWinPrice,
|
|
UserId: value.UserId,
|
|
PryNum: strconv.Itoa(value.PryNum),
|
|
},
|
|
}
|
|
|
|
// 订单状态
|
|
var marketStatus string
|
|
switch value.Status {
|
|
case 0:
|
|
marketStatus = setting.MarketShareFurEntrust
|
|
case 1:
|
|
marketStatus = setting.MarketShareFurPosition
|
|
default:
|
|
}
|
|
|
|
// 写入缓存数据(挂单|持仓)
|
|
if err := share.ShareFurHashUserOrder(Reds, marketStatus, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareFur.%v:%v", common.ErrShareFur, marketStatus, err)
|
|
return
|
|
}
|
|
|
|
// 写入用户订阅缓存
|
|
userCacheKey := fmt.Sprintf("%v-%v", setting.ShareFurSubscribe, value.UserId)
|
|
if err := share.ShareFurHashUserOrder(Reds, userCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareFur.%v:%v", common.ErrShareFur, userCacheKey, err)
|
|
return
|
|
}
|
|
|
|
// 写入管理员订阅缓存
|
|
adminCacheKey := setting.AdminShareFurSubscribe
|
|
if err := share.ShareFurHashUserOrder(Reds, adminCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareFur.%v:%v", common.ErrShareFur, adminCacheKey, err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
func RestoreCacheShareGbx(data *Data) {
|
|
var stockList []*models.BotStockGbxTrade
|
|
if err := data.mysqlDB.Table(flags.BotStockGbxTrade).
|
|
Where("status in (0,1)").
|
|
Asc("`status`").
|
|
Find(&stockList); err != nil {
|
|
return
|
|
}
|
|
|
|
for _, value := range stockList {
|
|
flatRatio := GetCacheForcedClosure(flags.StockUkSystemSetUpKey, value.StockId) // 设置强平阈值
|
|
leverStatus := SystemShareMarketLeverStatus(flags.StockMarketList, flags.GbxMarket, int64(value.UserId)) // 股票市场系统设置
|
|
system := &structure.ShareSystem{
|
|
StrongFlatRatio: flatRatio.String(), // 强平阈值
|
|
Status: leverStatus.Status, // 杠杆状态
|
|
StockMin: leverStatus.StockMin, // 开启杠杆的最小值
|
|
LevelMin: leverStatus.LevelMin, // 杠杆最小值
|
|
LevelMax: leverStatus.LevelMax, // 杠杆最大值
|
|
UserStatus: leverStatus.UserStatus, // 用户开启状态
|
|
}
|
|
closingTime := SystemTimeGenerate(flags.StockMarketList, flags.GbxMarket, time.Now()) // 开盘时间
|
|
shareOrder := &share.ShareGbxTallyCache{
|
|
UserId: int64(value.UserId),
|
|
OrderId: value.OrderId,
|
|
Symbol: value.StockId,
|
|
Status: strconv.Itoa(value.Status),
|
|
OpenPrice: value.DealPrice,
|
|
ClosingPrice: value.ClosingPrice,
|
|
ClosingTime: closingTime,
|
|
Order: structure.ShareOrder{
|
|
System: system,
|
|
StockId: value.StockId,
|
|
TradeType: int64(value.TradeType),
|
|
DealType: int64(value.DealType),
|
|
LimitPrice: value.LimitPrice,
|
|
MarketPrice: value.MarketPrice,
|
|
MarketMoney: value.MarketMoney,
|
|
OrderNumber: value.OrderNumber,
|
|
ServiceCost: value.ServiceCost,
|
|
StopType: int64(value.StopType),
|
|
StopLossPrice: value.StopLossPrice,
|
|
StopWinPrice: value.StopWinPrice,
|
|
UserId: value.UserId,
|
|
PryNum: strconv.Itoa(value.PryNum),
|
|
},
|
|
}
|
|
|
|
// 订单状态
|
|
var marketStatus string
|
|
switch value.Status {
|
|
case 0:
|
|
marketStatus = setting.MarketShareGbxEntrust
|
|
case 1:
|
|
marketStatus = setting.MarketShareGbxPosition
|
|
default:
|
|
}
|
|
|
|
// 写入缓存数据(挂单|持仓)
|
|
if err := share.ShareGbxHashUserOrder(Reds, marketStatus, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareGbx.%v:%v", common.ErrShareGbx, marketStatus, err)
|
|
return
|
|
}
|
|
|
|
// 写入用户订阅缓存
|
|
userCacheKey := fmt.Sprintf("%v-%v", setting.ShareGbxSubscribe, value.UserId)
|
|
if err := share.ShareGbxHashUserOrder(Reds, userCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareGbx.%v:%v", common.ErrShareGbx, userCacheKey, err)
|
|
return
|
|
}
|
|
|
|
// 写入管理员订阅缓存
|
|
adminCacheKey := setting.AdminShareGbxSubscribe
|
|
if err := share.ShareGbxHashUserOrder(Reds, adminCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareGbx.%v:%v", common.ErrShareGbx, adminCacheKey, err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// RestoreCacheShareTha
|
|
//
|
|
// @Description:
|
|
// @param data
|
|
func RestoreCacheShareTha(data *Data) {
|
|
var stockList []*models.BotStockThaTrade
|
|
if err := data.mysqlDB.Table(flags.BotStockThaTrade).
|
|
Where("status in (0,1)").
|
|
Asc("`status`").
|
|
Find(&stockList); err != nil {
|
|
return
|
|
}
|
|
|
|
for _, value := range stockList {
|
|
flatRatio := GetCacheForcedClosure(flags.StockTGSystemSetUpKey, value.StockId) // 设置强平阈值
|
|
leverStatus := SystemShareMarketLeverStatus(flags.StockMarketList, flags.ThaMarket, int64(value.UserId)) // 股票市场系统设置
|
|
system := &structure.ShareSystem{
|
|
StrongFlatRatio: flatRatio.String(), // 强平阈值
|
|
Status: leverStatus.Status, // 杠杆状态
|
|
StockMin: leverStatus.StockMin, // 开启杠杆的最小值
|
|
LevelMin: leverStatus.LevelMin, // 杠杆最小值
|
|
LevelMax: leverStatus.LevelMax, // 杠杆最大值
|
|
UserStatus: leverStatus.UserStatus, // 用户开启状态
|
|
}
|
|
closingTime := SystemTimeGenerate(flags.StockMarketList, flags.ThaMarket, time.Now()) // 开盘时间
|
|
shareOrder := &share.ShareThaTallyCache{
|
|
UserId: int64(value.UserId),
|
|
OrderId: value.OrderId,
|
|
Symbol: value.StockId,
|
|
Status: strconv.Itoa(value.Status),
|
|
OpenPrice: value.DealPrice,
|
|
ClosingPrice: value.ClosingPrice,
|
|
ClosingTime: closingTime,
|
|
Order: structure.ShareOrder{
|
|
System: system,
|
|
StockId: value.StockId,
|
|
TradeType: int64(value.TradeType),
|
|
DealType: int64(value.DealType),
|
|
LimitPrice: value.LimitPrice,
|
|
MarketPrice: value.MarketPrice,
|
|
MarketMoney: value.MarketMoney,
|
|
OrderNumber: value.OrderNumber,
|
|
ServiceCost: value.ServiceCost,
|
|
StopType: int64(value.StopType),
|
|
StopLossPrice: value.StopLossPrice,
|
|
StopWinPrice: value.StopWinPrice,
|
|
UserId: value.UserId,
|
|
PryNum: strconv.Itoa(value.PryNum),
|
|
},
|
|
}
|
|
|
|
// 订单状态
|
|
var marketStatus string
|
|
switch value.Status {
|
|
case 0:
|
|
marketStatus = setting.MarketShareThaEntrust
|
|
case 1:
|
|
marketStatus = setting.MarketShareThaPosition
|
|
default:
|
|
}
|
|
|
|
// 写入缓存数据(挂单|持仓)
|
|
if err := share.ShareThaHashUserOrder(Reds, marketStatus, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareTha.%v:%v", common.ErrShareTha, marketStatus, err)
|
|
return
|
|
}
|
|
|
|
// 写入用户订阅缓存
|
|
userCacheKey := fmt.Sprintf("%v-%v", setting.ShareThaSubscribe, value.UserId)
|
|
if err := share.ShareThaHashUserOrder(Reds, userCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareTha.%v:%v", common.ErrShareTha, userCacheKey, err)
|
|
return
|
|
}
|
|
|
|
// 写入管理员订阅缓存
|
|
adminCacheKey := setting.AdminShareThaSubscribe
|
|
if err := share.ShareThaHashUserOrder(Reds, adminCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareTha.%v:%v", common.ErrShareTha, adminCacheKey, err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// RestoreCacheShareMys
|
|
//
|
|
// @Description:
|
|
// @param data
|
|
func RestoreCacheShareMys(data *Data) {
|
|
var stockList []*models.BotStockMysTrade
|
|
if err := data.mysqlDB.Table(flags.BotStockMysTrade).
|
|
Where("status in (0,1)").
|
|
Asc("`status`").
|
|
Find(&stockList); err != nil {
|
|
return
|
|
}
|
|
|
|
for _, value := range stockList {
|
|
flatRatio := GetCacheForcedClosure(flags.StockMGSystemSetUpKey, value.StockId) // 设置强平阈值
|
|
leverStatus := SystemShareMarketLeverStatus(flags.StockMarketList, flags.MysMarket, int64(value.UserId)) // 股票市场系统设置
|
|
system := &structure.ShareSystem{
|
|
StrongFlatRatio: flatRatio.String(), // 强平阈值
|
|
Status: leverStatus.Status, // 杠杆状态
|
|
StockMin: leverStatus.StockMin, // 开启杠杆的最小值
|
|
LevelMin: leverStatus.LevelMin, // 杠杆最小值
|
|
LevelMax: leverStatus.LevelMax, // 杠杆最大值
|
|
UserStatus: leverStatus.UserStatus, // 用户开启状态
|
|
}
|
|
closingTime := SystemTimeGenerate(flags.StockMarketList, flags.MysMarket, time.Now()) // 开盘时间
|
|
shareOrder := &share.ShareMysTallyCache{
|
|
UserId: int64(value.UserId),
|
|
OrderId: value.OrderId,
|
|
Symbol: value.StockId,
|
|
Status: strconv.Itoa(value.Status),
|
|
OpenPrice: value.DealPrice,
|
|
ClosingPrice: value.ClosingPrice,
|
|
ClosingTime: closingTime,
|
|
Order: structure.ShareOrder{
|
|
System: system,
|
|
StockId: value.StockId,
|
|
TradeType: int64(value.TradeType),
|
|
DealType: int64(value.DealType),
|
|
LimitPrice: value.LimitPrice,
|
|
MarketPrice: value.MarketPrice,
|
|
MarketMoney: value.MarketMoney,
|
|
OrderNumber: value.OrderNumber,
|
|
ServiceCost: value.ServiceCost,
|
|
StopType: int64(value.StopType),
|
|
StopLossPrice: value.StopLossPrice,
|
|
StopWinPrice: value.StopWinPrice,
|
|
UserId: value.UserId,
|
|
PryNum: strconv.Itoa(value.PryNum),
|
|
},
|
|
}
|
|
|
|
// 订单状态
|
|
var marketStatus string
|
|
switch value.Status {
|
|
case 0:
|
|
marketStatus = setting.MarketShareMysEntrust
|
|
case 1:
|
|
marketStatus = setting.MarketShareMysPosition
|
|
default:
|
|
}
|
|
|
|
// 写入缓存数据(挂单|持仓)
|
|
if err := share.ShareMysHashUserOrder(Reds, marketStatus, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareMys.%v:%v", common.ErrShareMys, marketStatus, err)
|
|
return
|
|
}
|
|
|
|
// 写入用户订阅缓存
|
|
userCacheKey := fmt.Sprintf("%v-%v", setting.ShareMysSubscribe, value.UserId)
|
|
if err := share.ShareMysHashUserOrder(Reds, userCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareMys.%v:%v", common.ErrShareMys, userCacheKey, err)
|
|
return
|
|
}
|
|
|
|
// 写入管理员订阅缓存
|
|
adminCacheKey := setting.AdminShareMysSubscribe
|
|
if err := share.ShareMysHashUserOrder(Reds, adminCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareMys.%v:%v", common.ErrShareMys, adminCacheKey, err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// RestoreCacheShareIdn
|
|
//
|
|
// @Description:
|
|
// @param data
|
|
func RestoreCacheShareIdn(data *Data) {
|
|
var stockList []*models.BotStockIdnTrade
|
|
if err := data.mysqlDB.Table(flags.BotStockIdnTrade).
|
|
Where("status in (0,1)").
|
|
Asc("`status`").
|
|
Find(&stockList); err != nil {
|
|
return
|
|
}
|
|
|
|
for _, value := range stockList {
|
|
flatRatio := GetCacheForcedClosure(flags.StockYNSystemSetUpKey, value.StockId) // 设置强平阈值
|
|
leverStatus := SystemShareMarketLeverStatus(flags.StockMarketList, flags.IdnMarket, int64(value.UserId)) // 股票市场系统设置
|
|
system := &structure.ShareSystem{
|
|
StrongFlatRatio: flatRatio.String(), // 强平阈值
|
|
Status: leverStatus.Status, // 杠杆状态
|
|
StockMin: leverStatus.StockMin, // 开启杠杆的最小值
|
|
LevelMin: leverStatus.LevelMin, // 杠杆最小值
|
|
LevelMax: leverStatus.LevelMax, // 杠杆最大值
|
|
UserStatus: leverStatus.UserStatus, // 用户开启状态
|
|
}
|
|
closingTime := SystemTimeGenerate(flags.StockMarketList, flags.IdnMarket, time.Now()) // 开盘时间
|
|
shareOrder := &share.ShareIdnTallyCache{
|
|
UserId: int64(value.UserId),
|
|
OrderId: value.OrderId,
|
|
Symbol: value.StockId,
|
|
Status: strconv.Itoa(value.Status),
|
|
OpenPrice: value.DealPrice,
|
|
ClosingPrice: value.ClosingPrice,
|
|
ClosingTime: closingTime,
|
|
Order: structure.ShareOrder{
|
|
System: system,
|
|
StockId: value.StockId,
|
|
TradeType: int64(value.TradeType),
|
|
DealType: int64(value.DealType),
|
|
LimitPrice: value.LimitPrice,
|
|
MarketPrice: value.MarketPrice,
|
|
MarketMoney: value.MarketMoney,
|
|
OrderNumber: value.OrderNumber,
|
|
ServiceCost: value.ServiceCost,
|
|
StopType: int64(value.StopType),
|
|
StopLossPrice: value.StopLossPrice,
|
|
StopWinPrice: value.StopWinPrice,
|
|
UserId: value.UserId,
|
|
PryNum: strconv.Itoa(value.PryNum),
|
|
},
|
|
}
|
|
|
|
// 订单状态
|
|
var marketStatus string
|
|
switch value.Status {
|
|
case 0:
|
|
marketStatus = setting.MarketShareIdnEntrust
|
|
case 1:
|
|
marketStatus = setting.MarketShareIdnPosition
|
|
default:
|
|
}
|
|
|
|
// 写入缓存数据(挂单|持仓)
|
|
if err := share.ShareIdnHashUserOrder(Reds, marketStatus, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareIdn.%v:%v", common.ErrShareIdn, marketStatus, err)
|
|
return
|
|
}
|
|
|
|
// 写入用户订阅缓存
|
|
userCacheKey := fmt.Sprintf("%v-%v", setting.ShareIdnSubscribe, value.UserId)
|
|
if err := share.ShareIdnHashUserOrder(Reds, userCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareIdn.%v:%v", common.ErrShareIdn, userCacheKey, err)
|
|
return
|
|
}
|
|
|
|
// 写入管理员订阅缓存
|
|
adminCacheKey := setting.AdminShareIdnSubscribe
|
|
if err := share.ShareIdnHashUserOrder(Reds, adminCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareIdn.%v:%v", common.ErrShareIdn, adminCacheKey, err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// RestoreCacheShareInr
|
|
//
|
|
// @Description:
|
|
// @param data
|
|
func RestoreCacheShareInr(data *Data) {
|
|
var stockList []*models.BotStockInTrade
|
|
if err := data.mysqlDB.Table(flags.BotStockInTrade).
|
|
Where("status in (0,1)").
|
|
Asc("`status`").
|
|
Find(&stockList); err != nil {
|
|
return
|
|
}
|
|
|
|
for _, value := range stockList {
|
|
flatRatio := GetCacheForcedClosure(flags.StockYDSystemSetUpKey, value.StockId) // 设置强平阈值
|
|
leverStatus := SystemShareMarketLeverStatus(flags.StockMarketList, flags.InrMarket, int64(value.UserId)) // 股票市场系统设置
|
|
system := &structure.ShareSystem{
|
|
StrongFlatRatio: flatRatio.String(), // 强平阈值
|
|
Status: leverStatus.Status, // 杠杆状态
|
|
StockMin: leverStatus.StockMin, // 开启杠杆的最小值
|
|
LevelMin: leverStatus.LevelMin, // 杠杆最小值
|
|
LevelMax: leverStatus.LevelMax, // 杠杆最大值
|
|
UserStatus: leverStatus.UserStatus, // 用户开启状态
|
|
}
|
|
closingTime := SystemTimeGenerate(flags.StockMarketList, flags.InrMarket, time.Now()) // 开盘时间
|
|
shareOrder := &share.ShareInrTallyCache{
|
|
UserId: int64(value.UserId),
|
|
OrderId: value.OrderId,
|
|
Symbol: value.StockId,
|
|
Status: strconv.Itoa(value.Status),
|
|
OpenPrice: value.DealPrice,
|
|
ClosingPrice: value.ClosingPrice,
|
|
ClosingTime: closingTime,
|
|
Order: structure.ShareOrder{
|
|
System: system,
|
|
StockId: value.StockId,
|
|
TradeType: int64(value.TradeType),
|
|
DealType: int64(value.DealType),
|
|
LimitPrice: value.LimitPrice,
|
|
MarketPrice: value.MarketPrice,
|
|
MarketMoney: value.MarketMoney,
|
|
OrderNumber: value.OrderNumber,
|
|
ServiceCost: value.ServiceCost,
|
|
StopType: int64(value.StopType),
|
|
StopLossPrice: value.StopLossPrice,
|
|
StopWinPrice: value.StopWinPrice,
|
|
UserId: value.UserId,
|
|
PryNum: strconv.Itoa(value.PryNum),
|
|
},
|
|
}
|
|
|
|
// 订单状态
|
|
var marketStatus string
|
|
switch value.Status {
|
|
case 0:
|
|
marketStatus = setting.MarketShareInrEntrust
|
|
case 1:
|
|
marketStatus = setting.MarketShareInrPosition
|
|
default:
|
|
}
|
|
|
|
// 写入缓存数据(挂单|持仓)
|
|
if err := share.ShareInrHashUserOrder(Reds, marketStatus, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareInr.%v:%v", common.ErrShareInr, marketStatus, err)
|
|
return
|
|
}
|
|
|
|
// 写入用户订阅缓存
|
|
userCacheKey := fmt.Sprintf("%v-%v", setting.ShareInrSubscribe, value.UserId)
|
|
if err := share.ShareInrHashUserOrder(Reds, userCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareInr.%v:%v", common.ErrShareInr, userCacheKey, err)
|
|
return
|
|
}
|
|
|
|
// 写入管理员订阅缓存
|
|
adminCacheKey := setting.AdminShareInrSubscribe
|
|
if err := share.ShareInrHashUserOrder(Reds, adminCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareInr.%v:%v", common.ErrShareInr, adminCacheKey, err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// RestoreCacheShareSgd
|
|
//
|
|
// @Description:
|
|
// @param data
|
|
func RestoreCacheShareSgd(data *Data) {
|
|
var stockList []*models.BotStockSgdTrade
|
|
if err := data.mysqlDB.Table(flags.BotStockSgdTrade).
|
|
Where("status in (0,1)").
|
|
Asc("`status`").
|
|
Find(&stockList); err != nil {
|
|
return
|
|
}
|
|
|
|
for _, value := range stockList {
|
|
flatRatio := GetCacheForcedClosure(flags.StockSGDSystemSetUpKey, value.StockId) // 设置强平阈值
|
|
leverStatus := SystemShareMarketLeverStatus(flags.StockMarketList, flags.SgdMarket, int64(value.UserId)) // 股票市场系统设置
|
|
system := &structure.ShareSystem{
|
|
StrongFlatRatio: flatRatio.String(), // 强平阈值
|
|
Status: leverStatus.Status, // 杠杆状态
|
|
StockMin: leverStatus.StockMin, // 开启杠杆的最小值
|
|
LevelMin: leverStatus.LevelMin, // 杠杆最小值
|
|
LevelMax: leverStatus.LevelMax, // 杠杆最大值
|
|
UserStatus: leverStatus.UserStatus, // 用户开启状态
|
|
}
|
|
closingTime := SystemTimeGenerate(flags.StockMarketList, flags.SgdMarket, time.Now()) // 开盘时间
|
|
shareOrder := &share.ShareSgdTallyCache{
|
|
UserId: int64(value.UserId),
|
|
OrderId: value.OrderId,
|
|
Symbol: value.StockId,
|
|
Status: strconv.Itoa(value.Status),
|
|
OpenPrice: value.DealPrice,
|
|
ClosingPrice: value.ClosingPrice,
|
|
ClosingTime: closingTime,
|
|
Order: structure.ShareOrder{
|
|
System: system,
|
|
StockId: value.StockId,
|
|
TradeType: int64(value.TradeType),
|
|
DealType: int64(value.DealType),
|
|
LimitPrice: value.LimitPrice,
|
|
MarketPrice: value.MarketPrice,
|
|
MarketMoney: value.MarketMoney,
|
|
OrderNumber: value.OrderNumber,
|
|
ServiceCost: value.ServiceCost,
|
|
StopType: int64(value.StopType),
|
|
StopLossPrice: value.StopLossPrice,
|
|
StopWinPrice: value.StopWinPrice,
|
|
UserId: value.UserId,
|
|
PryNum: strconv.Itoa(value.PryNum),
|
|
},
|
|
}
|
|
|
|
// 订单状态
|
|
var marketStatus string
|
|
switch value.Status {
|
|
case 0:
|
|
marketStatus = setting.MarketShareSgdEntrust
|
|
case 1:
|
|
marketStatus = setting.MarketShareSgdPosition
|
|
default:
|
|
}
|
|
adminCacheKey := setting.AdminShareSgdSubscribe
|
|
userCacheKey := fmt.Sprintf("%v-%v", setting.ShareSgdSubscribe, value.UserId)
|
|
|
|
// 写入缓存数据(挂单|持仓)
|
|
if err := share.ShareSgdHashUserOrder(Reds, marketStatus, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareSgd.%v:%v", common.ErrShareSgd, marketStatus, err)
|
|
return
|
|
}
|
|
|
|
// 写入用户订阅缓存
|
|
if err := share.ShareSgdHashUserOrder(Reds, userCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareSgd.%v:%v", common.ErrShareSgd, userCacheKey, err)
|
|
return
|
|
}
|
|
|
|
// 写入管理员订阅缓存
|
|
if err := share.ShareSgdHashUserOrder(Reds, adminCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareSgd.%v:%v", common.ErrShareSgd, adminCacheKey, err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// RestoreCacheShareHkd
|
|
//
|
|
// @Description:
|
|
// @param data
|
|
func RestoreCacheShareHkd(data *Data) {
|
|
var stockList []*models.BotStockHkdTrade
|
|
if err := data.mysqlDB.Table(flags.BotStockHkdTrade).
|
|
Where("status in (0,1)").
|
|
Asc("`status`").
|
|
Find(&stockList); err != nil {
|
|
return
|
|
}
|
|
|
|
for _, value := range stockList {
|
|
flatRatio := GetCacheForcedClosure(flags.StockHKDSystemSetUpKey, value.StockId) // 设置强平阈值
|
|
leverStatus := SystemShareMarketLeverStatus(flags.StockMarketList, flags.HkdMarket, int64(value.UserId)) // 股票市场系统设置
|
|
system := &structure.ShareSystem{
|
|
StrongFlatRatio: flatRatio.String(), // 强平阈值
|
|
Status: leverStatus.Status, // 杠杆状态
|
|
StockMin: leverStatus.StockMin, // 开启杠杆的最小值
|
|
LevelMin: leverStatus.LevelMin, // 杠杆最小值
|
|
LevelMax: leverStatus.LevelMax, // 杠杆最大值
|
|
UserStatus: leverStatus.UserStatus, // 用户开启状态
|
|
}
|
|
closingTime := SystemTimeGenerate(flags.StockMarketList, flags.HkdMarket, time.Now()) // 开盘时间
|
|
shareOrder := &share.ShareHkdTallyCache{
|
|
UserId: int64(value.UserId),
|
|
OrderId: value.OrderId,
|
|
Symbol: value.StockId,
|
|
Status: strconv.Itoa(value.Status),
|
|
OpenPrice: value.DealPrice,
|
|
ClosingPrice: value.ClosingPrice,
|
|
ClosingTime: closingTime,
|
|
Order: structure.ShareOrder{
|
|
System: system,
|
|
StockId: value.StockId,
|
|
TradeType: int64(value.TradeType),
|
|
DealType: int64(value.DealType),
|
|
LimitPrice: value.LimitPrice,
|
|
MarketPrice: value.MarketPrice,
|
|
MarketMoney: value.MarketMoney,
|
|
OrderNumber: value.OrderNumber,
|
|
ServiceCost: value.ServiceCost,
|
|
StopType: int64(value.StopType),
|
|
StopLossPrice: value.StopLossPrice,
|
|
StopWinPrice: value.StopWinPrice,
|
|
UserId: value.UserId,
|
|
PryNum: strconv.Itoa(value.PryNum),
|
|
},
|
|
}
|
|
|
|
// 订单状态
|
|
var marketStatus string
|
|
switch value.Status {
|
|
case 0:
|
|
marketStatus = setting.MarketShareHkdEntrust
|
|
case 1:
|
|
marketStatus = setting.MarketShareHkdPosition
|
|
default:
|
|
}
|
|
adminCacheKey := setting.AdminShareHkdSubscribe
|
|
userCacheKey := fmt.Sprintf("%v-%v", setting.ShareHkdSubscribe, value.UserId)
|
|
|
|
// 写入缓存数据(挂单|持仓)
|
|
if err := share.ShareHkdHashUserOrder(Reds, marketStatus, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareHkd.%v:%v", common.ErrShareHkd, marketStatus, err)
|
|
return
|
|
}
|
|
|
|
// 写入用户订阅缓存
|
|
if err := share.ShareHkdHashUserOrder(Reds, userCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareHkd.%v:%v", common.ErrShareHkd, userCacheKey, err)
|
|
return
|
|
}
|
|
|
|
// 写入管理员订阅缓存
|
|
if err := share.ShareHkdHashUserOrder(Reds, adminCacheKey, shareOrder); err != nil {
|
|
applogger.Error("%v RestoreCacheShareHkd.%v:%v", common.ErrShareHkd, adminCacheKey, err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|