matchmaking-system/internal/data/subscribe_share_blk.go

package data

import (
	"context"
	"encoding/json"
	"github.com/shopspring/decimal"
	"matchmaking-system/internal/data/memory"
	"matchmaking-system/internal/data/socket/shareData"
	"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"
	"sync"
	"time"
)

/*
大宗(美股|泰股|马股|印尼股|印度股|新加坡股|港股|英股)交易股票行情订阅
1、接收用户大宗交易股下单的交易对大宗交易股行情
2、将订阅行情写入内存中用于并发计算
3、挂单(市价|限价)缓存队列处理-开仓
4、持仓缓存队列处理-平仓
*/

// InitCacheSymbolShareBlk
//
//	@Description: 初始化大宗交易代码列表
//	@param ctx
//	@param uo
func InitCacheSymbolShareBlk(ctx context.Context, uo *Data) {
	for {
		idnList, err := GetBotStockBlockListByStockId(ctx, uo)
		if err != nil {
			return
		}

		for key, value := range idnList {
			var cacheKey string
			switch key {
			case flags.ShareUsMarketType: // 美股
				cacheKey = setting.MarketShareBlkUs
			case flags.ShareThaMarketType: // 泰股
				cacheKey = setting.MarketShareBlkTha
			case flags.ShareMysMarketType: // 马股
				cacheKey = setting.MarketShareBlkMys
			case flags.ShareIdnMarketType: // 印尼股
				cacheKey = setting.MarketShareBlkIdn
			case flags.ShareInrMarketType: // 印度股
				cacheKey = setting.MarketShareBlkInr
			case flags.ShareSgdMarketType: // 新加坡股
				cacheKey = setting.MarketShareBlkSgd
			case flags.ShareHkdMarketType: // 港股
				cacheKey = setting.MarketShareBlkHkd
			case flags.ShareGbxMarketType: // 英股
				cacheKey = setting.MarketShareBlkGbx
			case flags.ShareEurMarketType: // 德股
				cacheKey = setting.MarketShareBlkEur
			case flags.ShareFurMarketType: // 法股
				cacheKey = setting.MarketShareBlkFur
			case flags.ShareBrlMarketType: // 巴西股
				cacheKey = setting.MarketShareBlkBrl
			case flags.ShareJpyMarketType: // 日股
				cacheKey = setting.MarketShareBlkJpy
			default:
				continue
			}
			for _, vue := range value {
				if err = InitRedisBlk(uo, vue, cacheKey); err != nil {
					continue
				}
			}
		}

		time.Sleep(10 * time.Second)
	}
}

// InitRedisBlk
//
//	@Description:
//	@param uo
//	@param vue
//	@param key
//	@return error
func InitRedisBlk(uo *Data, vue, key string) error {
	checkBool, err := Reds.HExists(context.Background(), key, vue).Result()
	if err != nil {
		applogger.Error("%v InitCacheSymbolShareBlk.%v.HExists:%v", common.ErrShareBlk, key, err)
		return err
	}
	if !checkBool {
		if err = uo.redisDB.HSet(context.Background(), key, vue, vue).Err(); err != nil {
			applogger.Error("%v InitCacheSymbolShareBlk.%v.HSet:%v", common.ErrShareBlk, key, err)
			return err
		}
	}
	if !flags.CheckSetting {
		applogger.Info("初始化大宗交易股票代码:%v", vue)
	}

	return nil
}

// InitSubscribeShareBlk
//
//	@Description: 初始化大宗交易代码缓存
//	@param shareBlk
func InitSubscribeShareBlk(
	shareUs *ShareUsSymbol, shareTha *ShareThaSymbol,
	shareMys *ShareMysSymbol, shareIdn *ShareIdnSymbol,
	shareInr *ShareInrSymbol, shareSgd *ShareSgdSymbol,
	shareHkd *ShareHkdSymbol, shareGbx *ShareGbxSymbol,
	shareEur *ShareEurSymbol, shareFur *ShareFurSymbol,
	shareBrl *ShareBrlSymbol, shareJpy *ShareJpySymbol) {
	go InitSubscribeShareUs(shareUs, true)   // 初始化美股交易代码缓存
	go InitSubscribeShareTha(shareTha, true) // 初始化泰股交易代码缓存
	go InitSubscribeShareMys(shareMys, true) // 初始化马股交易代码缓存
	go InitSubscribeShareIdn(shareIdn, true) // 初始化印尼股交易代码缓存
	go InitSubscribeShareInr(shareInr, true) // 初始化印度股交易代码缓存
	go InitSubscribeShareSgd(shareSgd, true) // 初始化新加坡股交易代码缓存
	go InitSubscribeShareHkd(shareHkd, true) // 初始化港股交易代码缓存
	go InitSubscribeShareGbx(shareGbx, true) // 初始化英股交易代码缓存
	go InitSubscribeShareEur(shareEur, true) // 初始化德股交易代码缓存
	go InitSubscribeShareFur(shareFur, true) // 初始化法股交易代码缓存
	go InitSubscribeShareBrl(shareBrl, true) // 初始化巴西股交易代码缓存
	go InitSubscribeShareJpy(shareJpy, true) // 初始化日本股交易代码缓存
}

// InitShareBlkCloseCachePrice
//
//	@Description:
//	@param shareUs
//	@param shareTha
//	@param shareMys
//	@param shareIdn
//	@param shareInr
//	@param shareSgd
//	@param shareHkd
func InitShareBlkCloseCachePrice() {
	go InitShareUsCloseCachePrice(true)  // 初始化美股交易代码闭盘价缓存
	go InitShareThaCloseCachePrice(true) // 初始化泰股交易代码闭盘价缓存
	go InitShareMysCloseCachePrice(true) // 初始化马股交易代码闭盘价缓存
	go InitShareIdnCloseCachePrice(true) // 初始化印尼股交易代码闭盘价缓存
	go InitShareInrCloseCachePrice(true) // 初始化印度股交易代码闭盘价缓存
	go InitShareSgdCloseCachePrice(true) // 初始化新加坡股交易代码闭盘价缓存
	go InitShareHkdCloseCachePrice(true) // 初始化港股交易代码闭盘价缓存
	go InitShareGbxCloseCachePrice(true) // 初始化英股交易代码闭盘价缓存
	go InitShareEurCloseCachePrice(true) // 初始化德股交易代码闭盘价缓存
	go InitShareFurCloseCachePrice(true) // 初始化法股交易代码闭盘价缓存
	go InitShareBrlCloseCachePrice(true) // 初始化巴西股交易代码闭盘价缓存
	go InitShareJpyCloseCachePrice(true) // 初始化日本股交易代码闭盘价缓存
}

// InitShareBlkSetUpPrice
//
//	@Description:
func InitShareBlkSetUpPrice() {
	go InitShareUsPriceSetUp(true)  // 初始化美股交易代码插针价缓存
	go InitShareThaPriceSetUp(true) // 初始化泰股交易代码插针价缓存
	go InitShareMysPriceSetUp(true) // 初始化马股交易代码插针价缓存
	go InitShareIdnPriceSetUp(true) // 初始化印尼股交易代码插针价缓存
	go InitShareInrPriceSetUp(true) // 初始化印度股交易代码插针价缓存
	go InitShareSgdPriceSetUp(true) // 初始化新加坡股交易代码插针价缓存
	go InitShareHkdPriceSetUp(true) // 初始化港股交易代码插针价缓存
	go InitShareGbxPriceSetUp(true) // 初始化英股交易代码插针价缓存
	go InitShareEurPriceSetUp(true) // 初始化德股交易代码插针价缓存
	go InitShareFurPriceSetUp(true) // 初始化法股交易代码插针价缓存
	go InitShareBrlPriceSetUp(true) // 初始化巴西股交易代码插针价缓存
	go InitShareJpyPriceSetUp(true) // 初始化日本股交易代码插针价缓存
}

// SubscribeShareBlk
//
//	@Description: 大宗交易下单交易对行情订阅
//	@param ctx
//	@param data
//	@param shareUs 美股
//	@param shareTha 泰股
//	@param shareMys 马股
//	@param shareIdn 印尼股
//	@param shareInr 印度股
//	@param shareSgd 新加坡股
//	@param shareHkd 港股
//	@param shareGbx 英股
func SubscribeShareBlk() {
	go InitShareUsCloseNewPrice(true)
	go InitShareThaCloseNewPrice(true)
	go InitShareMysCloseNewPrice(true)
	go InitShareIdnCloseNewPrice(true)
	go InitShareInrCloseNewPrice(true)
	go InitShareSgdCloseNewPrice(true)
	go InitShareHkdCloseNewPrice(true)
	go InitShareGbxCloseNewPrice(true)
	go InitShareFurCloseNewPrice(true)
	go InitShareEurCloseNewPrice(true)
	go InitShareBrlCloseNewPrice(true)
	go InitShareJpyCloseNewPrice(true)
}

// OrderSubAdminShareBlkSubscribeBySum
//
//	@Description: 大宗交易持仓订单浮动盈亏
//	@param uo
func OrderSubAdminShareBlkSubscribeBySum() {
	for {
		var topIc = setting.AdminShareBlkSubscribe
		hashMap, err := Reds.HGetAll(context.Background(), topIc).Result()
		if err != nil {
			applogger.Error("OrderSubAdminShareBlkSubscribeBySum.HGetAll:%v", err)
			time.Sleep(5 * time.Second)
			continue
		}
		var hashList []share.ShareBlkTallyCache
		for _, value := range hashMap {
			var msg share.ShareBlkTallyCache
			if err = json.Unmarshal([]byte(value), &msg); err != nil {
				time.Sleep(5 * time.Second)
				continue
			}
			switch msg.Status {
			case flags.Entrust: // 挂单
			case flags.Position: // 持仓
				hashList = append(hashList, msg)
			default: // 平仓|撤单
				err = Reds.HDel(context.Background(), topIc, msg.OrderId).Err()
				if err != nil {
					applogger.Error("OrderSubAdminShareBlkSubscribeBySum.HDel:%v", err)
					continue
				}
			}
		}
		applogger.Info("大宗交易股数据量统计:%v", len(hashList))
		// 统计泰股总持仓订单浮动盈亏
		priceSum := decimal.Zero
		for _, value := range hashList {
			orderModel := shareData.ShareBlkOrderProcessing(topIc, 1, value)
			if orderModel != nil {
				if len(orderModel.Price) == 0 || len(orderModel.OpenPrice) == 0 {
					continue
				}
				var subPrice decimal.Decimal
				newPrice := decimal.RequireFromString(orderModel.Price)
				openPrice := decimal.RequireFromString(orderModel.OpenPrice)
				switch value.Order.TradeType {
				case flags.TradeTypeBuy: // 买涨 = 新价格 - 开仓价
					subPrice = newPrice.Sub(openPrice)
				case flags.TradeTypeSell: // 卖跌 = 开仓价 - 新价格
					subPrice = openPrice.Sub(newPrice)
				default:
					subPrice = decimal.Zero
				}
				price := subPrice.Mul(decimal.RequireFromString(value.Order.OrderNumber))
				priceSum = priceSum.Add(price) // 累加盈亏统计
			}
		}
		// 写入缓存
		if err = memory.ShareBlkFloating.Set(flags.FloatingBlk, []byte(priceSum.String())); err != nil {
			applogger.Error("统计大宗交易股持仓订单浮动盈亏错误:%v", err)
			time.Sleep(5 * time.Second)
			continue
		}
		applogger.Info("统计大宗交易股持仓订单浮动盈亏:%v", priceSum)

		time.Sleep(1 * time.Second)
	}
}

// ShareBlkTransactionEntrust
//
//	@Description: 大宗(美股|泰股|马股|印尼股|印度股|新加坡股|港股|英股|巴西股|日本股)交易挂单信息缓存队列
//	@param ctx
func ShareBlkTransactionEntrust(ctx context.Context) {
	go ShareBlkUsTransactionEntrust(ctx)
	go ShareBlkThaTransactionEntrust(ctx)
	go ShareBlkMysTransactionEntrust(ctx)
	go ShareBlkIdnTransactionEntrust(ctx)
	go ShareBlkInrTransactionEntrust(ctx)
	go ShareBlkSgdTransactionEntrust(ctx)
	go ShareBlkHkdTransactionEntrust(ctx)
	go ShareBlkGbxTransactionEntrust(ctx)
	go ShareBlkEurTransactionEntrust(ctx)
	go ShareBlkFurTransactionEntrust(ctx)
	go ShareBlkBrlTransactionEntrust(ctx)
	go ShareBlkJpyTransactionEntrust(ctx)
}

// ShareBlkUsTransactionEntrust
//
//	@Description: 大宗(美股)交易
//	@param ctx
func ShareBlkUsTransactionEntrust(ctx context.Context) {
	for {
		ShareBlkUsTransactionCalculationEntrust(ctx)
		time.Sleep(600 * time.Millisecond)
	}
}

// ShareBlkThaTransactionEntrust
//
//	@Description: 大宗(泰股)交易
//	@param ctx
func ShareBlkThaTransactionEntrust(ctx context.Context) {
	for {
		ShareBlkThaTransactionCalculationEntrust(ctx)
		time.Sleep(600 * time.Millisecond)
	}
}

// ShareBlkMysTransactionEntrust
//
//	@Description: 大宗(马股)交易
//	@param ctx
func ShareBlkMysTransactionEntrust(ctx context.Context) {
	for {
		ShareBlkMysTransactionCalculationEntrust(ctx)
		time.Sleep(600 * time.Millisecond)
	}
}

// ShareBlkIdnTransactionEntrust
//
//	@Description: 大宗(印尼股)交易
//	@param ctx
func ShareBlkIdnTransactionEntrust(ctx context.Context) {
	for {
		ShareBlkIdnTransactionCalculationEntrust(ctx)
		time.Sleep(600 * time.Millisecond)
	}
}

// ShareBlkInrTransactionEntrust
//
//	@Description: 大宗(印度股)交易
//	@param ctx
func ShareBlkInrTransactionEntrust(ctx context.Context) {
	for {
		ShareBlkInrTransactionCalculationEntrust(ctx)
		time.Sleep(600 * time.Millisecond)
	}
}

// ShareBlkSgdTransactionEntrust
//
//	@Description: 大宗(新加坡股)交易
//	@param ctx
func ShareBlkSgdTransactionEntrust(ctx context.Context) {
	for {
		ShareBlkSgdTransactionCalculationEntrust(ctx)
		time.Sleep(600 * time.Millisecond)
	}
}

// ShareBlkHkdTransactionEntrust
//
//	@Description: 大宗(港股)交易
//	@param ctx
func ShareBlkHkdTransactionEntrust(ctx context.Context) {
	for {
		ShareBlkHkdTransactionCalculationEntrust(ctx)
		time.Sleep(600 * time.Millisecond)
	}
}

// ShareBlkGbxTransactionEntrust
//
//	@Description: 大宗(英股)交易
//	@param ctx
func ShareBlkGbxTransactionEntrust(ctx context.Context) {
	for {
		ShareBlkGbxTransactionCalculationEntrust(ctx)
		time.Sleep(600 * time.Millisecond)
	}
}

// ShareBlkEurTransactionEntrust
//
//	@Description: 大宗(德股)交易
//	@param ctx
func ShareBlkEurTransactionEntrust(ctx context.Context) {
	for {
		ShareBlkEurTransactionCalculationEntrust(ctx)
		time.Sleep(600 * time.Millisecond)
	}
}

// ShareBlkFurTransactionEntrust
//
//	@Description: 大宗(德股)交易
//	@param ctx
func ShareBlkFurTransactionEntrust(ctx context.Context) {
	for {
		ShareBlkFurTransactionCalculationEntrust(ctx)
		time.Sleep(600 * time.Millisecond)
	}
}

// ShareBlkBrlTransactionEntrust
//
//	@Description: 大宗(巴西股)交易
//	@param ctx
func ShareBlkBrlTransactionEntrust(ctx context.Context) {
	for {
		ShareBlkBrlTransactionCalculationEntrust(ctx)
		time.Sleep(600 * time.Millisecond)
	}
}

// ShareBlkJpyTransactionEntrust
//
//	@Description: 大宗(日本股)交易
//	@param ctx
func ShareBlkJpyTransactionEntrust(ctx context.Context) {
	for {
		ShareBlkJpyTransactionCalculationEntrust(ctx)
		time.Sleep(600 * time.Millisecond)
	}
}

// ShareBlkUsTransactionCalculationEntrust
//
//	@Description: 大宗(美股)交易挂单业务逻辑处理
//	@param ctx
func ShareBlkUsTransactionCalculationEntrust(ctx context.Context) {
	var wg sync.WaitGroup

	// 获取挂单缓存列表
	orderMap, err := Reds.HGetAll(context.Background(), setting.MarketShareBlkEntrust).Result()
	if err != nil {
		applogger.Error("%v ShareBlkTransactionCalculationEntrust.HGetAll:%v", common.ErrShareBlk, err)
		return
	}

	for _, value := range orderMap {
		var newPrice decimal.Decimal
		var entrustUs share.ShareUsTallyCache
		var entrust share.ShareBlkTallyCache
		var msg = make(chan share.ShareUsTallyCache, 1)
		if err = json.Unmarshal([]byte(value), &entrust); err != nil {
			applogger.Error("%v ShareBlkTransactionCalculationEntrust.Unmarshal:%v", common.ErrShareBlk, err)
			continue
		}
		if entrust.Order.Type != flags.ShareUsMarketType {
			continue
		}
		newPrice = decimal.RequireFromString(entrust.OpenPrice) // 固定开仓设置价格
		entrustUs = share.ShareUsTallyCache{
			UserId:       entrust.UserId,
			OrderId:      entrust.OrderId,
			Symbol:       entrust.Symbol,
			Status:       entrust.Status,
			OpenPrice:    entrust.OpenPrice,
			ClosingPrice: entrust.ClosingPrice,
			ClosingTime:  entrust.ClosingTime,
			Order:        entrust.Order,
		}

		wg.Add(1)
		go func(value string) {
			resultMsg := ShareBlockUsConcurrentComputingEntrustMarket(&entrustUs, newPrice, &wg)
			msg <- resultMsg
		}(value)

		// 处理并发结果(需要改成通过信道通知)
		select {
		case resultMsg, _ := <-msg:
			switch resultMsg.Status {
			case flags.Entrust: // 挂单中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收大宗(美股)交易股挂单信息:%v", resultMsg)
				}
			case flags.Position: // 持仓中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收到大宗(美股)交易股持仓信息:%v", resultMsg)
				}
				// 开盘逻辑
				if err = ShareUsLiquidationEntrust(ctx, &resultMsg); err != nil {
					applogger.Error("%v ShareBlkTransactionCalculationEntrust.ShareUsLiquidationEntrust:%v", common.ErrShareBlk, err)

					resultMsg.Status = flags.Entrust
					resultMsg.OpenPrice = decimal.Zero.String()
					byteStr, _ := json.Marshal(resultMsg)
					_ = Reds.HSet(context.Background(), setting.MarketShareBlkEntrust, resultMsg.OrderId, string(byteStr)).Err()
					continue
				}
				// 写入持仓缓存列表
				var byteStr []byte
				byteStr, err = json.Marshal(resultMsg)
				if err != nil {
					applogger.Error("%v ShareBlkTransactionCalculationEntrust.Marshal:%v", common.ErrShareBlk, err)
					continue
				}
				// 写入持仓队列缓存
				if err = Reds.HSet(context.Background(), setting.MarketShareBlkPosition, resultMsg.OrderId, string(byteStr)).Err(); err != nil {
					continue
				}
			}
		}
	}

	wg.Wait()
	applogger.Info("大宗(美股)交易股挂单并发计算执行完毕......")
}

// ShareBlkThaTransactionCalculationEntrust
//
//	@Description: 大宗(泰股)交易挂单业务逻辑处理
//	@param ctx
func ShareBlkThaTransactionCalculationEntrust(ctx context.Context) {
	var wg sync.WaitGroup

	// 获取挂单缓存列表
	orderMap, err := Reds.HGetAll(context.Background(), setting.MarketShareBlkEntrust).Result()
	if err != nil {
		applogger.Error("%v ShareBlkTransactionCalculationEntrust.HGetAll:%v", common.ErrShareBlk, err)
		return
	}

	for _, value := range orderMap {
		var newPrice decimal.Decimal
		var entrustTha share.ShareThaTallyCache
		var entrust share.ShareBlkTallyCache
		var msg = make(chan share.ShareThaTallyCache, 1)
		if err = json.Unmarshal([]byte(value), &entrust); err != nil {
			applogger.Error("%v ShareBlkTransactionCalculationEntrust.Unmarshal:%v", common.ErrShareBlk, err)
			continue
		}
		if entrust.Order.Type != flags.ShareThaMarketType {
			continue
		}
		newPrice = decimal.RequireFromString(entrust.OpenPrice) // 固定开仓设置价格
		entrustTha = share.ShareThaTallyCache{
			UserId:       entrust.UserId,
			OrderId:      entrust.OrderId,
			Symbol:       entrust.Symbol,
			Status:       entrust.Status,
			OpenPrice:    entrust.OpenPrice,
			ClosingPrice: entrust.ClosingPrice,
			ClosingTime:  entrust.ClosingTime,
			Order:        entrust.Order,
		}

		wg.Add(1)
		go func(value string) {
			resultMsg := ShareBlockThaConcurrentComputingEntrustMarket(&entrustTha, newPrice, &wg)
			msg <- resultMsg
		}(value)

		// 处理并发结果(需要改成通过信道通知)
		select {
		case resultMsg, _ := <-msg:
			switch resultMsg.Status {
			case flags.Entrust: // 挂单中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收大宗(泰股)交易股挂单信息:%v", resultMsg)
				}
			case flags.Position: // 持仓中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收到大宗(泰股)交易股持仓信息:%v", resultMsg)
				}
				// 开盘逻辑
				if err = ShareThaLiquidationEntrust(ctx, &resultMsg); err != nil {
					applogger.Error("%v ShareBlkTransactionCalculationEntrust.ShareThaLiquidationEntrust:%v", common.ErrShareBlk, err)

					resultMsg.Status = flags.Entrust
					resultMsg.OpenPrice = decimal.Zero.String()
					byteStr, _ := json.Marshal(resultMsg)
					_ = Reds.HSet(context.Background(), setting.MarketShareBlkEntrust, resultMsg.OrderId, string(byteStr)).Err()
					continue
				}
				// 写入持仓缓存列表
				var byteStr []byte
				byteStr, err = json.Marshal(resultMsg)
				if err != nil {
					applogger.Error("%v ShareBlkTransactionCalculationEntrust.Marshal:%v", common.ErrShareBlk, err)
					continue
				}
				// 写入持仓队列缓存
				if err = Reds.HSet(context.Background(), setting.MarketShareBlkPosition, resultMsg.OrderId, string(byteStr)).Err(); err != nil {
					continue
				}
			}
		}
	}

	wg.Wait()
	applogger.Info("大宗(泰股)交易股挂单并发计算执行完毕......")
}

// ShareBlkMysTransactionCalculationEntrust
//
//	@Description: 大宗(马股)交易挂单业务逻辑处理
//	@param ctx
func ShareBlkMysTransactionCalculationEntrust(ctx context.Context) {
	var wg sync.WaitGroup

	// 获取挂单缓存列表
	orderMap, err := Reds.HGetAll(context.Background(), setting.MarketShareBlkEntrust).Result()
	if err != nil {
		applogger.Error("%v ShareBlkTransactionCalculationEntrust.HGetAll:%v", common.ErrShareBlk, err)
		return
	}

	for _, value := range orderMap {
		var newPrice decimal.Decimal
		var entrustMys share.ShareMysTallyCache
		var entrust share.ShareBlkTallyCache
		var msg = make(chan share.ShareMysTallyCache, 1)
		if err = json.Unmarshal([]byte(value), &entrust); err != nil {
			applogger.Error("%v ShareBlkTransactionCalculationEntrust.Unmarshal:%v", common.ErrShareBlk, err)
			continue
		}
		if entrust.Order.Type != flags.ShareMysMarketType {
			continue
		}
		newPrice = decimal.RequireFromString(entrust.OpenPrice) // 固定开仓设置价格
		entrustMys = share.ShareMysTallyCache{
			UserId:       entrust.UserId,
			OrderId:      entrust.OrderId,
			Symbol:       entrust.Symbol,
			Status:       entrust.Status,
			OpenPrice:    entrust.OpenPrice,
			ClosingPrice: entrust.ClosingPrice,
			ClosingTime:  entrust.ClosingTime,
			Order:        entrust.Order,
		}

		wg.Add(1)
		go func(value string) {
			resultMsg := ShareBlockMysConcurrentComputingEntrustMarket(&entrustMys, newPrice, &wg)
			msg <- resultMsg
		}(value)

		// 处理并发结果(需要改成通过信道通知)
		select {
		case resultMsg, _ := <-msg:
			switch resultMsg.Status {
			case flags.Entrust: // 挂单中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收大宗(马股)交易股挂单信息:%v", resultMsg)
				}
			case flags.Position: // 持仓中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收到大宗(马股)交易股持仓信息:%v", resultMsg)
				}
				// 开盘逻辑
				if err = ShareMysLiquidationEntrust(ctx, &resultMsg); err != nil {
					applogger.Error("%v ShareBlkTransactionCalculationEntrust.ShareMysLiquidationEntrust:%v", common.ErrShareBlk, err)

					resultMsg.Status = flags.Entrust
					resultMsg.OpenPrice = decimal.Zero.String()
					byteStr, _ := json.Marshal(resultMsg)
					_ = Reds.HSet(context.Background(), setting.MarketShareBlkEntrust, resultMsg.OrderId, string(byteStr)).Err()
					continue
				}
				// 写入持仓缓存列表
				var byteStr []byte
				byteStr, err = json.Marshal(resultMsg)
				if err != nil {
					applogger.Error("%v ShareBlkTransactionCalculationEntrust.Marshal:%v", common.ErrShareBlk, err)
					continue
				}
				// 写入持仓队列缓存
				if err = Reds.HSet(context.Background(), setting.MarketShareBlkPosition, resultMsg.OrderId, string(byteStr)).Err(); err != nil {
					continue
				}
			}
		}
	}

	wg.Wait()
	applogger.Info("大宗(马股)交易股挂单并发计算执行完毕......")
}

// ShareBlkIdnTransactionCalculationEntrust
//
//	@Description: 大宗(印尼股)交易挂单业务逻辑处理
//	@param ctx
func ShareBlkIdnTransactionCalculationEntrust(ctx context.Context) {
	var wg sync.WaitGroup

	// 获取挂单缓存列表
	orderMap, err := Reds.HGetAll(context.Background(), setting.MarketShareBlkEntrust).Result()
	if err != nil {
		applogger.Error("%v ShareBlkTransactionCalculationEntrust.HGetAll:%v", common.ErrShareBlk, err)
		return
	}

	for _, value := range orderMap {
		var newPrice decimal.Decimal
		var entrustIdn share.ShareIdnTallyCache
		var entrust share.ShareBlkTallyCache
		var msg = make(chan share.ShareIdnTallyCache, 1)
		if err = json.Unmarshal([]byte(value), &entrust); err != nil {
			applogger.Error("%v ShareBlkTransactionCalculationEntrust.Unmarshal:%v", common.ErrShareBlk, err)
			continue
		}
		if entrust.Order.Type != flags.ShareIdnMarketType {
			continue
		}
		newPrice = decimal.RequireFromString(entrust.OpenPrice) // 固定开仓设置价格
		entrustIdn = share.ShareIdnTallyCache{
			UserId:       entrust.UserId,
			OrderId:      entrust.OrderId,
			Symbol:       entrust.Symbol,
			Status:       entrust.Status,
			OpenPrice:    entrust.OpenPrice,
			ClosingPrice: entrust.ClosingPrice,
			ClosingTime:  entrust.ClosingTime,
			Order:        entrust.Order,
		}

		wg.Add(1)
		go func(value string) {
			resultMsg := ShareBlockIdnConcurrentComputingEntrustMarket(&entrustIdn, newPrice, &wg)
			msg <- resultMsg
		}(value)

		// 处理并发结果(需要改成通过信道通知)
		select {
		case resultMsg, _ := <-msg:
			switch resultMsg.Status {
			case flags.Entrust: // 挂单中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收大宗(印尼股)交易股挂单信息:%v", resultMsg)
				}
			case flags.Position: // 持仓中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收到大宗(印尼股)交易股持仓信息:%v", resultMsg)
				}
				// 开盘逻辑
				if err = ShareIdnLiquidationEntrust(ctx, &resultMsg); err != nil {
					applogger.Error("%v ShareBlkTransactionCalculationEntrust.ShareIdnLiquidationEntrust:%v", common.ErrShareBlk, err)

					resultMsg.Status = flags.Entrust
					resultMsg.OpenPrice = decimal.Zero.String()
					byteStr, _ := json.Marshal(resultMsg)
					_ = Reds.HSet(context.Background(), setting.MarketShareBlkEntrust, resultMsg.OrderId, string(byteStr)).Err()
					continue
				}
				// 写入持仓缓存列表
				var byteStr []byte
				byteStr, err = json.Marshal(resultMsg)
				if err != nil {
					applogger.Error("%v ShareBlkTransactionCalculationEntrust.Marshal:%v", common.ErrShareBlk, err)
					continue
				}
				// 写入持仓队列缓存
				if err = Reds.HSet(context.Background(), setting.MarketShareBlkPosition, resultMsg.OrderId, string(byteStr)).Err(); err != nil {
					continue
				}
			}
		}
	}

	wg.Wait()
	applogger.Info("大宗(印尼股)交易股挂单并发计算执行完毕......")
}

// ShareBlkInrTransactionCalculationEntrust
//
//	@Description: 大宗(印度股)交易挂单业务逻辑处理
//	@param ctx
func ShareBlkInrTransactionCalculationEntrust(ctx context.Context) {
	var wg sync.WaitGroup

	// 获取挂单缓存列表
	orderMap, err := Reds.HGetAll(context.Background(), setting.MarketShareBlkEntrust).Result()
	if err != nil {
		applogger.Error("%v ShareBlkTransactionCalculationEntrust.HGetAll:%v", common.ErrShareBlk, err)
		return
	}

	for _, value := range orderMap {
		var newPrice decimal.Decimal
		var entrustInr share.ShareInrTallyCache
		var entrust share.ShareBlkTallyCache
		var msg = make(chan share.ShareInrTallyCache, 1)
		if err = json.Unmarshal([]byte(value), &entrust); err != nil {
			applogger.Error("%v ShareBlkTransactionCalculationEntrust.Unmarshal:%v", common.ErrShareBlk, err)
			continue
		}
		if entrust.Order.Type != flags.ShareInrMarketType {
			continue
		}
		newPrice = decimal.RequireFromString(entrust.OpenPrice) // 固定开仓设置价格
		entrustInr = share.ShareInrTallyCache{
			UserId:       entrust.UserId,
			OrderId:      entrust.OrderId,
			Symbol:       entrust.Symbol,
			Status:       entrust.Status,
			OpenPrice:    entrust.OpenPrice,
			ClosingPrice: entrust.ClosingPrice,
			ClosingTime:  entrust.ClosingTime,
			Order:        entrust.Order,
		}

		wg.Add(1)
		go func(value string) {
			resultMsg := ShareBlockInrConcurrentComputingEntrustMarket(&entrustInr, newPrice, &wg)
			msg <- resultMsg
		}(value)

		// 处理并发结果(需要改成通过信道通知)
		select {
		case resultMsg, _ := <-msg:
			switch resultMsg.Status {
			case flags.Entrust: // 挂单中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收大宗(印度股)交易股挂单信息:%v", resultMsg)
				}
			case flags.Position: // 持仓中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收到大宗(印度股)交易股持仓信息:%v", resultMsg)
				}
				// 开盘逻辑
				if err = ShareInrLiquidationEntrust(ctx, &resultMsg); err != nil {
					applogger.Error("%v ShareBlkTransactionCalculationEntrust.ShareInrLiquidationEntrust:%v", common.ErrShareBlk, err)

					resultMsg.Status = flags.Entrust
					resultMsg.OpenPrice = decimal.Zero.String()
					byteStr, _ := json.Marshal(resultMsg)
					_ = Reds.HSet(context.Background(), setting.MarketShareBlkEntrust, resultMsg.OrderId, string(byteStr)).Err()
					continue
				}
				// 写入持仓缓存列表
				var byteStr []byte
				byteStr, err = json.Marshal(resultMsg)
				if err != nil {
					applogger.Error("%v ShareBlkTransactionCalculationEntrust.Marshal:%v", common.ErrShareBlk, err)
					continue
				}
				// 写入持仓队列缓存
				if err = Reds.HSet(context.Background(), setting.MarketShareBlkPosition, resultMsg.OrderId, string(byteStr)).Err(); err != nil {
					continue
				}
			}
		}
	}

	wg.Wait()
	applogger.Info("大宗(印度股)交易股挂单并发计算执行完毕......")
}

// ShareBlkSgdTransactionCalculationEntrust
//
//	@Description: 大宗(新加坡股)交易挂单业务逻辑处理
//	@param ctx
func ShareBlkSgdTransactionCalculationEntrust(ctx context.Context) {
	var wg sync.WaitGroup

	// 获取挂单缓存列表
	orderMap, err := Reds.HGetAll(context.Background(), setting.MarketShareBlkEntrust).Result()
	if err != nil {
		applogger.Error("%v ShareBlkTransactionCalculationEntrust.HGetAll:%v", common.ErrShareBlk, err)
		return
	}

	for _, value := range orderMap {
		var newPrice decimal.Decimal
		var entrustSgd share.ShareSgdTallyCache
		var entrust share.ShareBlkTallyCache
		var msg = make(chan share.ShareSgdTallyCache, 1)
		if err = json.Unmarshal([]byte(value), &entrust); err != nil {
			applogger.Error("%v ShareBlkTransactionCalculationEntrust.Unmarshal:%v", common.ErrShareBlk, err)
			continue
		}
		if entrust.Order.Type != flags.ShareSgdMarketType {
			continue
		}
		newPrice = decimal.RequireFromString(entrust.OpenPrice) // 固定开仓设置价格
		entrustSgd = share.ShareSgdTallyCache{
			UserId:       entrust.UserId,
			OrderId:      entrust.OrderId,
			Symbol:       entrust.Symbol,
			Status:       entrust.Status,
			OpenPrice:    entrust.OpenPrice,
			ClosingPrice: entrust.ClosingPrice,
			ClosingTime:  entrust.ClosingTime,
			Order:        entrust.Order,
		}

		wg.Add(1)
		go func(value string) {
			resultMsg := ShareBlockSgdConcurrentComputingEntrustMarket(&entrustSgd, newPrice, &wg)
			msg <- resultMsg
		}(value)

		// 处理并发结果(需要改成通过信道通知)
		select {
		case resultMsg, _ := <-msg:
			switch resultMsg.Status {
			case flags.Entrust: // 挂单中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收大宗(新加坡股)交易股挂单信息:%v", resultMsg)
				}
			case flags.Position: // 持仓中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收到大宗(新加坡股)交易股持仓信息:%v", resultMsg)
				}
				// 开盘逻辑
				if err = ShareSgdLiquidationEntrust(ctx, &resultMsg); err != nil {
					applogger.Error("%v ShareBlkTransactionCalculationEntrust.ShareSgdLiquidationEntrust:%v", common.ErrShareBlk, err)

					resultMsg.Status = flags.Entrust
					resultMsg.OpenPrice = decimal.Zero.String()
					byteStr, _ := json.Marshal(resultMsg)
					_ = Reds.HSet(context.Background(), setting.MarketShareBlkEntrust, resultMsg.OrderId, string(byteStr)).Err()
					continue
				}
				// 写入持仓缓存列表
				var byteStr []byte
				byteStr, err = json.Marshal(resultMsg)
				if err != nil {
					applogger.Error("%v ShareBlkTransactionCalculationEntrust.Marshal:%v", common.ErrShareBlk, err)
					continue
				}
				// 写入持仓队列缓存
				if err = Reds.HSet(context.Background(), setting.MarketShareBlkPosition, resultMsg.OrderId, string(byteStr)).Err(); err != nil {
					continue
				}
			}
		}
	}

	wg.Wait()
	applogger.Info("大宗(新加坡股)交易股挂单并发计算执行完毕......")
}

// ShareBlkHkdTransactionCalculationEntrust
//
//	@Description: 大宗(港股)交易挂单业务逻辑处理
//	@param ctx
func ShareBlkHkdTransactionCalculationEntrust(ctx context.Context) {
	var wg sync.WaitGroup

	// 获取挂单缓存列表
	orderMap, err := Reds.HGetAll(context.Background(), setting.MarketShareBlkEntrust).Result()
	if err != nil {
		applogger.Error("%v ShareBlkTransactionCalculationEntrust.HGetAll:%v", common.ErrShareBlk, err)
		return
	}

	for _, value := range orderMap {
		var newPrice decimal.Decimal
		var entrust share.ShareBlkTallyCache
		var entrustHkd share.ShareHkdTallyCache
		var msg = make(chan share.ShareHkdTallyCache, 1)
		if err = json.Unmarshal([]byte(value), &entrust); err != nil {
			applogger.Error("%v ShareBlkTransactionCalculationEntrust.Unmarshal:%v", common.ErrShareBlk, err)
			continue
		}
		if entrust.Order.Type != flags.ShareHkdMarketType {
			continue

		}
		newPrice = decimal.RequireFromString(entrust.OpenPrice) // 固定开仓设置价格
		entrustHkd = share.ShareHkdTallyCache{
			UserId:       entrust.UserId,
			OrderId:      entrust.OrderId,
			Symbol:       entrust.Symbol,
			Status:       entrust.Status,
			OpenPrice:    entrust.OpenPrice,
			ClosingPrice: entrust.ClosingPrice,
			ClosingTime:  entrust.ClosingTime,
			Order:        entrust.Order,
		}

		wg.Add(1)
		go func(value string) {
			resultMsg := ShareBlockHkdConcurrentComputingEntrustMarket(&entrustHkd, newPrice, &wg)
			msg <- resultMsg
		}(value)

		// 处理并发结果(需要改成通过信道通知)
		select {
		case resultMsg, _ := <-msg:
			switch resultMsg.Status {
			case flags.Entrust: // 挂单中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收大宗(港股)交易股挂单信息:%v", resultMsg)
				}
			case flags.Position: // 持仓中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收到大宗(港股)交易股持仓信息:%v", resultMsg)
				}
				// 开盘逻辑
				if err = ShareHkdLiquidationEntrust(ctx, &resultMsg); err != nil {
					applogger.Error("%v ShareBlkTransactionCalculationEntrust.ShareHkdLiquidationEntrust:%v", common.ErrShareBlk, err)

					resultMsg.Status = flags.Entrust
					resultMsg.OpenPrice = decimal.Zero.String()
					byteStr, _ := json.Marshal(resultMsg)
					_ = Reds.HSet(context.Background(), setting.MarketShareBlkEntrust, resultMsg.OrderId, string(byteStr)).Err()
					continue
				}
				// 写入持仓缓存列表
				var byteStr []byte
				byteStr, err = json.Marshal(resultMsg)
				if err != nil {
					applogger.Error("%v ShareBlkTransactionCalculationEntrust.Marshal:%v", common.ErrShareBlk, err)
					continue
				}
				// 写入持仓队列缓存
				if err = Reds.HSet(context.Background(), setting.MarketShareBlkPosition, resultMsg.OrderId, string(byteStr)).Err(); err != nil {
					continue
				}
			}
		}
	}

	wg.Wait()
	applogger.Info("大宗(港股)交易股挂单并发计算执行完毕......")
}

// ShareBlkGbxTransactionCalculationEntrust
//
//	@Description: 大宗(英股)交易挂单业务逻辑处理
//	@param ctx
func ShareBlkGbxTransactionCalculationEntrust(ctx context.Context) {
	var wg sync.WaitGroup

	// 获取挂单缓存列表
	orderMap, err := Reds.HGetAll(context.Background(), setting.MarketShareBlkEntrust).Result()
	if err != nil {
		applogger.Error("%v ShareBlkGbxTransactionCalculationEntrust.HGetAll:%v", common.ErrShareBlk, err)
		return
	}

	for _, value := range orderMap {
		var newPrice decimal.Decimal
		var entrustSgd share.ShareGbxTallyCache
		var entrust share.ShareBlkTallyCache
		var msg = make(chan share.ShareGbxTallyCache, 1)
		if err = json.Unmarshal([]byte(value), &entrust); err != nil {
			applogger.Error("%v ShareBlkTransactionCalculationEntrust.Unmarshal:%v", common.ErrShareBlk, err)
			continue
		}
		if entrust.Order.Type != flags.ShareGbxMarketType {
			continue
		}
		newPrice = decimal.RequireFromString(entrust.OpenPrice) // 固定开仓设置价格
		entrustSgd = share.ShareGbxTallyCache{
			UserId:       entrust.UserId,
			OrderId:      entrust.OrderId,
			Symbol:       entrust.Symbol,
			Status:       entrust.Status,
			OpenPrice:    entrust.OpenPrice,
			ClosingPrice: entrust.ClosingPrice,
			ClosingTime:  entrust.ClosingTime,
			Order:        entrust.Order,
		}

		wg.Add(1)
		go func(value string) {
			resultMsg := ShareBlockGbxConcurrentComputingEntrustMarket(&entrustSgd, newPrice, &wg)
			msg <- resultMsg
		}(value)

		// 处理并发结果(需要改成通过信道通知)
		select {
		case resultMsg, _ := <-msg:
			switch resultMsg.Status {
			case flags.Entrust: // 挂单中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收大宗(英股)交易股挂单信息:%v", resultMsg)
				}
			case flags.Position: // 持仓中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收到大宗(英股)交易股持仓信息:%v", resultMsg)
				}
				// 开盘逻辑
				if err = ShareGbxLiquidationEntrust(ctx, &resultMsg); err != nil {
					applogger.Error("%v ShareBlkTransactionCalculationEntrust.ShareGbxLiquidationEntrust:%v", common.ErrShareBlk, err)

					resultMsg.Status = flags.Entrust
					resultMsg.OpenPrice = decimal.Zero.String()
					byteStr, _ := json.Marshal(resultMsg)
					_ = Reds.HSet(context.Background(), setting.MarketShareBlkEntrust, resultMsg.OrderId, string(byteStr)).Err()
					continue
				}
				// 写入持仓缓存列表
				var byteStr []byte
				byteStr, err = json.Marshal(resultMsg)
				if err != nil {
					applogger.Error("%v ShareBlkTransactionCalculationEntrust.Marshal:%v", common.ErrShareBlk, err)
					continue
				}
				// 写入持仓队列缓存
				if err = Reds.HSet(context.Background(), setting.MarketShareBlkPosition, resultMsg.OrderId, string(byteStr)).Err(); err != nil {
					continue
				}
			}
		}
	}

	wg.Wait()
	applogger.Info("大宗(英股)交易股挂单并发计算执行完毕......")
}

// ShareBlkEurTransactionCalculationEntrust
//
//	@Description: 大宗(德股)交易挂单业务逻辑处理
//	@param ctx
func ShareBlkEurTransactionCalculationEntrust(ctx context.Context) {
	var wg sync.WaitGroup

	// 获取挂单缓存列表
	orderMap, err := Reds.HGetAll(context.Background(), setting.MarketShareBlkEntrust).Result()
	if err != nil {
		applogger.Error("%v ShareBlkEurTransactionCalculationEntrust.HGetAll:%v", common.ErrShareBlk, err)
		return
	}

	for _, value := range orderMap {
		var newPrice decimal.Decimal
		var entrustSgd share.ShareEurTallyCache
		var entrust share.ShareBlkTallyCache
		var msg = make(chan share.ShareEurTallyCache, 1)
		if err = json.Unmarshal([]byte(value), &entrust); err != nil {
			applogger.Error("%v ShareBlkEurTransactionCalculationEntrust.Unmarshal:%v", common.ErrShareBlk, err)
			continue
		}
		if entrust.Order.Type != flags.ShareEurMarketType {
			continue
		}
		newPrice = decimal.RequireFromString(entrust.OpenPrice) // 固定开仓设置价格
		entrustSgd = share.ShareEurTallyCache{
			UserId:       entrust.UserId,
			OrderId:      entrust.OrderId,
			Symbol:       entrust.Symbol,
			Status:       entrust.Status,
			OpenPrice:    entrust.OpenPrice,
			ClosingPrice: entrust.ClosingPrice,
			ClosingTime:  entrust.ClosingTime,
			Order:        entrust.Order,
		}

		wg.Add(1)
		go func(value string) {
			resultMsg := ShareBlockEurConcurrentComputingEntrustMarket(&entrustSgd, newPrice, &wg)
			msg <- resultMsg
		}(value)

		// 处理并发结果(需要改成通过信道通知)
		select {
		case resultMsg, _ := <-msg:
			switch resultMsg.Status {
			case flags.Entrust: // 挂单中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收大宗(德股)交易股挂单信息:%v", resultMsg)
				}
			case flags.Position: // 持仓中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收到大宗(德股)交易股持仓信息:%v", resultMsg)
				}
				// 开盘逻辑
				if err = ShareEurLiquidationEntrust(ctx, &resultMsg); err != nil {
					applogger.Error("%v ShareBlkEurTransactionCalculationEntrust.ShareEurLiquidationEntrust:%v", common.ErrShareBlk, err)

					resultMsg.Status = flags.Entrust
					resultMsg.OpenPrice = decimal.Zero.String()
					byteStr, _ := json.Marshal(resultMsg)
					_ = Reds.HSet(context.Background(), setting.MarketShareBlkEntrust, resultMsg.OrderId, string(byteStr)).Err()
					continue
				}
				// 写入持仓缓存列表
				var byteStr []byte
				byteStr, err = json.Marshal(resultMsg)
				if err != nil {
					applogger.Error("%v ShareBlkEurTransactionCalculationEntrust.Marshal:%v", common.ErrShareBlk, err)
					continue
				}
				// 写入持仓队列缓存
				if err = Reds.HSet(context.Background(), setting.MarketShareBlkPosition, resultMsg.OrderId, string(byteStr)).Err(); err != nil {
					continue
				}
			}
		}
	}

	wg.Wait()
	applogger.Info("大宗(德股)交易股挂单并发计算执行完毕......")
}

// ShareBlkFurTransactionCalculationEntrust
//
//	@Description: 大宗(法股)交易挂单业务逻辑处理
//	@param ctx
func ShareBlkFurTransactionCalculationEntrust(ctx context.Context) {
	var wg sync.WaitGroup

	// 获取挂单缓存列表
	orderMap, err := Reds.HGetAll(context.Background(), setting.MarketShareBlkEntrust).Result()
	if err != nil {
		applogger.Error("%v ShareBlkFurTransactionCalculationEntrust.HGetAll:%v", common.ErrShareBlk, err)
		return
	}

	for _, value := range orderMap {
		var newPrice decimal.Decimal
		var entrustSgd share.ShareFurTallyCache
		var entrust share.ShareBlkTallyCache
		var msg = make(chan share.ShareFurTallyCache, 1)
		if err = json.Unmarshal([]byte(value), &entrust); err != nil {
			applogger.Error("%v ShareBlkFurTransactionCalculationEntrust.Unmarshal:%v", common.ErrShareBlk, err)
			continue
		}
		if entrust.Order.Type != flags.ShareFurMarketType {
			continue
		}
		newPrice = decimal.RequireFromString(entrust.OpenPrice) // 固定开仓设置价格
		entrustSgd = share.ShareFurTallyCache{
			UserId:       entrust.UserId,
			OrderId:      entrust.OrderId,
			Symbol:       entrust.Symbol,
			Status:       entrust.Status,
			OpenPrice:    entrust.OpenPrice,
			ClosingPrice: entrust.ClosingPrice,
			ClosingTime:  entrust.ClosingTime,
			Order:        entrust.Order,
		}

		wg.Add(1)
		go func(value string) {
			resultMsg := ShareBlockFurConcurrentComputingEntrustMarket(&entrustSgd, newPrice, &wg)
			msg <- resultMsg
		}(value)

		// 处理并发结果(需要改成通过信道通知)
		select {
		case resultMsg, _ := <-msg:
			switch resultMsg.Status {
			case flags.Entrust: // 挂单中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收大宗(法股)交易股挂单信息:%v", resultMsg)
				}
			case flags.Position: // 持仓中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收到大宗(法股)交易股持仓信息:%v", resultMsg)
				}
				// 开盘逻辑
				if err = ShareFurLiquidationEntrust(ctx, &resultMsg); err != nil {
					applogger.Error("%v ShareBlkFurTransactionCalculationEntrust.ShareFurLiquidationEntrust:%v", common.ErrShareBlk, err)

					resultMsg.Status = flags.Entrust
					resultMsg.OpenPrice = decimal.Zero.String()
					byteStr, _ := json.Marshal(resultMsg)
					_ = Reds.HSet(context.Background(), setting.MarketShareBlkEntrust, resultMsg.OrderId, string(byteStr)).Err()
					continue
				}
				// 写入持仓缓存列表
				var byteStr []byte
				byteStr, err = json.Marshal(resultMsg)
				if err != nil {
					applogger.Error("%v ShareBlkFurTransactionCalculationEntrust.Marshal:%v", common.ErrShareBlk, err)
					continue
				}
				// 写入持仓队列缓存
				if err = Reds.HSet(context.Background(), setting.MarketShareBlkPosition, resultMsg.OrderId, string(byteStr)).Err(); err != nil {
					continue
				}
			}
		}
	}

	wg.Wait()
	applogger.Info("大宗(法股)交易股挂单并发计算执行完毕......")
}

// ShareBlkBrlTransactionCalculationEntrust
//
//	@Description: 大宗(巴西股)交易挂单业务逻辑处理
//	@param ctx
func ShareBlkBrlTransactionCalculationEntrust(ctx context.Context) {
	var wg sync.WaitGroup

	// 获取挂单缓存列表
	orderMap, err := Reds.HGetAll(context.Background(), setting.MarketShareBlkEntrust).Result()
	if err != nil {
		applogger.Error("%v ShareBlkBrlTransactionCalculationEntrust.HGetAll:%v", common.ErrShareBlk, err)
		return
	}

	for _, value := range orderMap {
		var newPrice decimal.Decimal
		var entrustSgd share.ShareBrlTallyCache
		var entrust share.ShareBlkTallyCache
		var msg = make(chan share.ShareBrlTallyCache, 1)
		if err = json.Unmarshal([]byte(value), &entrust); err != nil {
			applogger.Error("%v ShareBlkBrlTransactionCalculationEntrust.Unmarshal:%v", common.ErrShareBlk, err)
			continue
		}
		if entrust.Order.Type != flags.ShareBrlMarketType {
			continue
		}
		newPrice = decimal.RequireFromString(entrust.OpenPrice) // 固定开仓设置价格
		entrustSgd = share.ShareBrlTallyCache{
			UserId:       entrust.UserId,
			OrderId:      entrust.OrderId,
			Symbol:       entrust.Symbol,
			Status:       entrust.Status,
			OpenPrice:    entrust.OpenPrice,
			ClosingPrice: entrust.ClosingPrice,
			ClosingTime:  entrust.ClosingTime,
			Order:        entrust.Order,
		}

		wg.Add(1)
		go func(value string) {
			resultMsg := ShareBlockBrlConcurrentComputingEntrustMarket(&entrustSgd, newPrice, &wg)
			msg <- resultMsg
		}(value)

		// 处理并发结果(需要改成通过信道通知)
		select {
		case resultMsg, _ := <-msg:
			switch resultMsg.Status {
			case flags.Entrust: // 挂单中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收大宗(巴西股)交易股挂单信息:%v", resultMsg)
				}
			case flags.Position: // 持仓中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收到大宗(巴西股)交易股持仓信息:%v", resultMsg)
				}
				// 开盘逻辑
				if err = ShareBrlLiquidationEntrust(ctx, &resultMsg); err != nil {
					applogger.Error("%v ShareBlkBrlTransactionCalculationEntrust.ShareBrlLiquidationEntrust:%v", common.ErrShareBlk, err)

					resultMsg.Status = flags.Entrust
					resultMsg.OpenPrice = decimal.Zero.String()
					byteStr, _ := json.Marshal(resultMsg)
					_ = Reds.HSet(context.Background(), setting.MarketShareBlkEntrust, resultMsg.OrderId, string(byteStr)).Err()
					continue
				}
				// 写入持仓缓存列表
				var byteStr []byte
				byteStr, err = json.Marshal(resultMsg)
				if err != nil {
					applogger.Error("%v ShareBlkBrlTransactionCalculationEntrust.Marshal:%v", common.ErrShareBlk, err)
					continue
				}
				// 写入持仓队列缓存
				if err = Reds.HSet(context.Background(), setting.MarketShareBlkPosition, resultMsg.OrderId, string(byteStr)).Err(); err != nil {
					continue
				}
			}
		}
	}

	wg.Wait()
	applogger.Info("大宗(巴西股)交易股挂单并发计算执行完毕......")
}

// ShareBlkJpyTransactionCalculationEntrust
//
//	@Description: 大宗(日股)交易挂单业务逻辑处理
//	@param ctx
func ShareBlkJpyTransactionCalculationEntrust(ctx context.Context) {
	var wg sync.WaitGroup

	// 获取挂单缓存列表
	orderMap, err := Reds.HGetAll(context.Background(), setting.MarketShareBlkEntrust).Result()
	if err != nil {
		applogger.Error("%v ShareBlkJpyTransactionCalculationEntrust.HGetAll:%v", common.ErrShareBlk, err)
		return
	}

	for _, value := range orderMap {
		var newPrice decimal.Decimal
		var entrustJpy share.ShareJpyTallyCache
		var entrust share.ShareBlkTallyCache
		var msg = make(chan share.ShareJpyTallyCache, 1)
		if err = json.Unmarshal([]byte(value), &entrust); err != nil {
			applogger.Error("%v ShareBlkJpyTransactionCalculationEntrust.Unmarshal:%v", common.ErrShareBlk, err)
			continue
		}
		if entrust.Order.Type != flags.ShareJpyMarketType {
			continue
		}
		newPrice = decimal.RequireFromString(entrust.OpenPrice) // 固定开仓设置价格
		entrustJpy = share.ShareJpyTallyCache{
			UserId:       entrust.UserId,
			OrderId:      entrust.OrderId,
			Symbol:       entrust.Symbol,
			Status:       entrust.Status,
			OpenPrice:    entrust.OpenPrice,
			ClosingPrice: entrust.ClosingPrice,
			ClosingTime:  entrust.ClosingTime,
			Order:        entrust.Order,
		}

		wg.Add(1)
		go func(value string) {
			resultMsg := ShareBlockJpyConcurrentComputingEntrustMarket(&entrustJpy, newPrice, &wg)
			msg <- resultMsg
		}(value)

		// 处理并发结果(需要改成通过信道通知)
		select {
		case resultMsg, _ := <-msg:
			switch resultMsg.Status {
			case flags.Entrust: // 挂单中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收大宗(日股)交易股挂单信息:%v", resultMsg)
				}
			case flags.Position: // 持仓中
				if !flags.CheckSetting {
					applogger.Debug("从信道接收到大宗(日股)交易股持仓信息:%v", resultMsg)
				}
				// 开盘逻辑
				if err = ShareJpyLiquidationEntrust(ctx, &resultMsg); err != nil {
					applogger.Error("%v ShareBlkJpyTransactionCalculationEntrust.ShareJpyLiquidationEntrust:%v", common.ErrShareBlk, err)

					resultMsg.Status = flags.Entrust
					resultMsg.OpenPrice = decimal.Zero.String()
					byteStr, _ := json.Marshal(resultMsg)
					_ = Reds.HSet(context.Background(), setting.MarketShareBlkEntrust, resultMsg.OrderId, string(byteStr)).Err()
					continue
				}
				// 写入持仓缓存列表
				var byteStr []byte
				byteStr, err = json.Marshal(resultMsg)
				if err != nil {
					applogger.Error("%v ShareBlkJpyTransactionCalculationEntrust.Marshal:%v", common.ErrShareBlk, err)
					continue
				}
				// 写入持仓队列缓存
				if err = Reds.HSet(context.Background(), setting.MarketShareBlkPosition, resultMsg.OrderId, string(byteStr)).Err(); err != nil {
					continue
				}
			}
		}
	}

	wg.Wait()
	applogger.Info("大宗(日股)交易股挂单并发计算执行完毕......")
}