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
		}
	}
}