matchmaking-system/internal/data/control.go

package data

import (
	"github.com/go-kratos/kratos/v2/log"
	"github.com/go-xorm/xorm"
	"github.com/redis/go-redis/v9"
	"matchmaking-system/internal/biz"
	"matchmaking-system/internal/pkg/flags"
	"matchmaking-system/internal/pkg/logging/applogger"
	"strings"
	"sync"
)

var (
	Reds *redis.Client
	Msql *xorm.EngineGroup
	Uo   *userOrderRepo

	spots     *SpotsSymbol     // 数字币-现货
	contract  *ContractSymbol  // 数字币-合约
	second    *SecondSymbol    // 数字币-秒合约
	forexWh   *ForexSymbol     // 外汇
	moneyZh   *MoneySymbol     // 综合(现货|合约|外汇)
	shareUs   *ShareUsSymbol   // 股票-美股
	shareIdn  *ShareIdnSymbol  // 股票-印尼
	shareMys  *ShareMysSymbol  // 股票-马股
	shareTha  *ShareThaSymbol  // 股票-泰股
	shareInr  *ShareInrSymbol  // 股票-印度
	shareGbx  *ShareGbxSymbol  // 股票-英国
	shareSgd  *ShareSgdSymbol  // 股票-新加坡
	shareHkd  *ShareHkdSymbol  // 股票-香港
	shareEur  *ShareEurSymbol  // 股票-德国
	shareFur  *ShareFurSymbol  // 股票-法国
	shareBrl  *ShareBrlSymbol  // 股票-巴西
	shareJpy  *ShareJpySymbol  // 股票-日本
	optionInr *OptionInrSymbol // 期权-印度
)

// userOrderRepo
// @Description:
type userOrderRepo struct {
	data *Data

	log *log.Helper
}

// InitBase
//
//	@Description: 初始化工具
//	@param ctx
//	@param uo
func InitBase(uo *Data) {
	Reds = uo.redisDB
	Msql = uo.mysqlDB
	Uo = &userOrderRepo{}
	// 数字币
	spots = &SpotsSymbol{SpotsMap: make(chan []byte), SpotsMapSymbol: sync.Map{}}
	second = &SecondSymbol{SecondMap: make(chan []byte), SecondMapSymbol: sync.Map{}}
	contract = &ContractSymbol{ContractMap: make(chan []byte), ContractMapSymbol: sync.Map{}}
	forexWh = &ForexSymbol{ForexMap: make(chan []byte), ForexMapSymbol: sync.Map{}}
	// 综合
	moneyZh = &MoneySymbol{MoneySpotsMap: make(chan []byte), MoneySpotsMapSymbol: sync.Map{},
		MoneyContractMap: make(chan []byte), MoneyContractMapSymbol: sync.Map{},
		MoneyForexMap: make(chan []byte), MoneyForexMapSymbol: sync.Map{}}
	// 股票
	shareUs = &ShareUsSymbol{UsMap: make(chan []byte), UsSetMap: make(chan []byte), UsMapSymbol: sync.Map{}, UsSetMapSymbol: sync.Map{}}
	shareMys = &ShareMysSymbol{MysMap: make(chan []byte), MysSetMap: make(chan []byte), MysMapSymbol: sync.Map{}, MysSetMapSymbol: sync.Map{}}
	shareTha = &ShareThaSymbol{ThaMap: make(chan []byte), ThaSetMap: make(chan []byte), ThaMapSymbol: sync.Map{}, ThaSetMapSymbol: sync.Map{}}
	shareIdn = &ShareIdnSymbol{IdnMap: make(chan []byte), IdnSetMap: make(chan []byte), IdnMapSymbol: sync.Map{}, IdnSetMapSymbol: sync.Map{}}
	shareInr = &ShareInrSymbol{InrMap: make(chan []byte), InrSetMap: make(chan []byte), InrMapSymbol: sync.Map{}, InrSetMapSymbol: sync.Map{}}
	shareGbx = &ShareGbxSymbol{GbxMap: make(chan []byte), GbxSetMap: make(chan []byte), GbxMapSymbol: sync.Map{}, GbxSetMapSymbol: sync.Map{}}
	shareSgd = &ShareSgdSymbol{SgdMap: make(chan []byte), SgdSetMap: make(chan []byte), SgdMapSymbol: sync.Map{}, SgdSetMapSymbol: sync.Map{}}
	shareHkd = &ShareHkdSymbol{HkdMap: make(chan []byte), HkdSetMap: make(chan []byte), HkdMapSymbol: sync.Map{}, HkdSetMapSymbol: sync.Map{}}
	shareEur = &ShareEurSymbol{EurMap: make(chan []byte), EurSetMap: make(chan []byte), EurMapSymbol: sync.Map{}, EurSetMapSymbol: sync.Map{}}
	shareFur = &ShareFurSymbol{FurMap: make(chan []byte), FurSetMap: make(chan []byte), FurMapSymbol: sync.Map{}, FurSetMapSymbol: sync.Map{}}
	shareBrl = &ShareBrlSymbol{BrlMap: make(chan []byte), BrlSetMap: make(chan []byte), BrlMapSymbol: sync.Map{}, BrlSetMapSymbol: sync.Map{}}
	shareJpy = &ShareJpySymbol{JpyMap: make(chan []byte), JpySetMap: make(chan []byte), JpyMapSymbol: sync.Map{}, JpySetMapSymbol: sync.Map{}}
	optionInr = &OptionInrSymbol{OpiMap: make(chan []byte), OpiSetMap: make(chan []byte), OpiMapSymbol: sync.Map{}, OpiSetMapSymbol: sync.Map{}}
}

// NewUserOrderRepo
//
//	@Description: 初始化交易对和股票代码
//	@param data
//	@param logger
//	@return biz.UserOrderRepo
func NewUserOrderRepo(data *Data, logger log.Logger) biz.UserOrderRepo {
	InitBase(data)

	switch flags.CheckEnvironment {
	case flags.CheckSymbolInit: // 交易对初始化
		InitSymbol(data)
	case flags.CheckShareInit: // 股票代码初始化
		InitCode(data)
	case flags.CheckCacheInit: // 初始化订单缓存
		InitCache(data)
	case flags.CheckClearInit: // 清理多余订单缓存
		InitClearCacheOrder(data)
	case flags.CheckByOrderNoInit: // 恢复IPO订单OrderNo匹配OrderId
		InitIpoRedisCacheOrder(data)
	case flags.CheckAdmin: // 管理订阅Wss服务
		checkSecond := strings.Contains(flags.CheckAdminService, flags.CheckSecond)       // 秒合约
		checkContract := strings.Contains(flags.CheckAdminService, flags.CheckContract)   // 合约
		checkForex := strings.Contains(flags.CheckAdminService, flags.CheckForex)         // 外汇
		checkMoney := strings.Contains(flags.CheckAdminService, flags.CheckMoney)         // 综合(现货|合约|外汇)
		checkShareUs := strings.Contains(flags.CheckAdminService, flags.CheckShareUs)     // 美股
		checkShareTha := strings.Contains(flags.CheckAdminService, flags.CheckShareTha)   // 泰股
		checkShareIdn := strings.Contains(flags.CheckAdminService, flags.CheckShareIdn)   // 印尼股
		checkShareInr := strings.Contains(flags.CheckAdminService, flags.CheckShareInr)   // 印度股
		checkShareMys := strings.Contains(flags.CheckAdminService, flags.CheckShareMys)   // 马股
		checkShareSgd := strings.Contains(flags.CheckAdminService, flags.CheckShareSgd)   // 新加坡股
		checkShareHkd := strings.Contains(flags.CheckAdminService, flags.CheckShareHkd)   // 港股
		checkShareGbx := strings.Contains(flags.CheckAdminService, flags.CheckShareGbx)   // 英股
		checkShareFur := strings.Contains(flags.CheckAdminService, flags.CheckShareFur)   // 法股
		checkShareEur := strings.Contains(flags.CheckAdminService, flags.CheckShareEur)   // 德股
		checkShareJpy := strings.Contains(flags.CheckAdminService, flags.CheckShareJpy)   // 日股
		checkShareBrl := strings.Contains(flags.CheckAdminService, flags.CheckShareBrl)   // 巴西股
		checkOptionInr := strings.Contains(flags.CheckAdminService, flags.CheckOptionInr) // 期权股
		if checkSecond {
			InitAdminSecond(data)
		}
		if checkContract {
			InitAdminContract(data)
		}
		if checkForex {
			InitAdminForex(data)
		}
		if checkMoney {
			InitAdminMoney(data)
		}
		if checkShareUs {
			InitAdminShareUs(data)
		}
		if checkShareTha {
			InitAdminShareTha(data)
		}
		if checkShareIdn {
			InitAdminShareIdn(data)
		}
		if checkShareInr {
			InitAdminShareInr(data)
		}
		if checkShareMys {
			InitAdminShareMys(data)
		}
		if checkShareSgd {
			InitAdminShareSgd(data)
		}
		if checkShareHkd {
			InitAdminShareHkd(data)
		}
		if checkShareGbx {
			InitAdminShareGbx(data)
		}
		if checkShareFur {
			InitAdminShareFur(data)
		}
		if checkShareEur {
			InitAdminShareEur(data)
		}
		if checkShareJpy {
			InitAdminShareJpy(data)
		}
		if checkShareBrl {
			InitAdminShareBrl(data)
		}
		if checkOptionInr {
			InitAdminOptionInr(data)
		}
	default:
		applogger.Debug("NewUserOrderRepo:请输入初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserSpotsRepo
//
//	@Description: 现货服务
//	@param data
//	@param logger
//	@return biz.UserSpotsOrderRepo
func NewUserSpotsRepo(data *Data, logger log.Logger) biz.UserSpotsOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckSport: // 现货服务
		InitSpots(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入现货初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserSecondRepo
//
//	@Description: 秒合约服务
//	@param data
//	@param logger
//	@return biz.UserSecondOrderRepo
func NewUserSecondRepo(data *Data, logger log.Logger) biz.UserSecondOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckSecond: // 秒合约服务
		InitSecond(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入秒合约初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserContractRepo
//
//	@Description: 合约服务
//	@param data
//	@param logger
//	@return biz.UserContractOrderRepo
func NewUserContractRepo(data *Data, logger log.Logger) biz.UserContractOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckContract: // 合约服务
		InitContract(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入合约初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserForexRepo
//
//	@Description: 外汇服务
//	@param data
//	@param logger
//	@return biz.UserForexOrderRepo
func NewUserForexRepo(data *Data, logger log.Logger) biz.UserForexOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckForex: // 合约服务
		InitForex(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入外汇初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserMoneyRepo
//
//	@Description: 综合-(现货|合约|外汇)
//	@param data
//	@param logger
//	@return biz.UserMoneyOrderRepo
func NewUserMoneyRepo(data *Data, logger log.Logger) biz.UserMoneyOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckMoney: // 综合(现货|合约|外汇)服务
		InitMoney(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入综合(现货|合约|外汇)初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserShareUsRepo
//
//	@Description: 美股
//	@param data
//	@param logger
//	@return biz.UserShareUsOrderRepo
func NewUserShareUsRepo(data *Data, logger log.Logger) biz.UserShareUsOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckShareUs: // 美股服务
		InitStockUs(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入美股初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserShareThaRepo
//
//	@Description: 泰股
//	@param data
//	@param logger
//	@return biz.UserShareThaOrderRepo
func NewUserShareThaRepo(data *Data, logger log.Logger) biz.UserShareThaOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckShareTha: // 泰股服务
		InitStockTha(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入泰股初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserShareIdnRepo
//
//	@Description: 印尼股
//	@param data
//	@param logger
//	@return biz.UserShareIdnOrderRepo
func NewUserShareIdnRepo(data *Data, logger log.Logger) biz.UserShareIdnOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckShareIdn: // 印尼股服务
		InitStockIdn(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入印尼股初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserShareInrRepo
//
//	@Description: 印度股
//	@param data
//	@param logger
//	@return biz.UserShareInrOrderRepo
func NewUserShareInrRepo(data *Data, logger log.Logger) biz.UserShareInrOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckShareInr: // 印度股服务
		InitStockInr(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入印度股初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserShareGbxRepo
//
//	@Description: 英股
//	@param data
//	@param logger
//	@return biz.UserShareGbxOrderRepo
func NewUserShareGbxRepo(data *Data, logger log.Logger) biz.UserShareGbxOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckShareGbx: // 英股服务
		InitStockGbx(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入英股初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserShareMysRepo
//
//	@Description: 马股
//	@param data
//	@param logger
//	@return biz.UserShareMysOrderRepo
func NewUserShareMysRepo(data *Data, logger log.Logger) biz.UserShareMysOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckShareMys: // 马股服务
		InitStockMys(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入马股初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserShareSgdRepo
//
//	@Description: 新加坡股
//	@param data
//	@param logger
//	@return biz.UserShareSgdOrderRepo
func NewUserShareSgdRepo(data *Data, logger log.Logger) biz.UserShareSgdOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckShareSgd: // 新加坡股服务
		InitStockSgd(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入新加坡股初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserShareEurRepo
//
//	@Description: 德股
//	@param data
//	@param logger
//	@return biz.UserShareEurOrderRepo
func NewUserShareEurRepo(data *Data, logger log.Logger) biz.UserShareEurOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckShareEur: // 德股服务
		InitStockEur(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入德股初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserShareBrlRepo
//
//	@Description: 德股
//	@param data
//	@param logger
//	@return biz.UserShareBrlOrderRepo
func NewUserShareBrlRepo(data *Data, logger log.Logger) biz.UserShareBrlOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckShareBrl: // 巴西股服务
		InitStockBrl(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入巴西股初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserShareFurRepo
//
//	@Description: 法股
//	@param data
//	@param logger
//	@return biz.UserShareFurOrderRepo
func NewUserShareFurRepo(data *Data, logger log.Logger) biz.UserShareFurOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckShareFur: // 法股服务
		InitStockFur(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入法股初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserShareJpyRepo
//
//	@Description: 日股
//	@param data
//	@param logger
//	@return biz.UserShareJpyOrderRepo
func NewUserShareJpyRepo(data *Data, logger log.Logger) biz.UserShareJpyOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckShareJpy: // 日股服务
		InitStockJpy(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入日股初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserShareHkdRepo
//
//	@Description: 港股
//	@param data
//	@param logger
//	@return biz.UserShareHkdOrderRepo
func NewUserShareHkdRepo(data *Data, logger log.Logger) biz.UserShareHkdOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckShareHkd: // 港股服务
		InitStockHkd(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入港股初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserOptionInrRepo
//
//	@Description: 期权-印度股
//	@param data
//	@param logger
//	@return biz.UserOptionInrOrderRepo
func NewUserOptionInrRepo(data *Data, logger log.Logger) biz.UserOptionInrOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckOptionInr: // 印度期权股服务
		InitOptionInr(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入期权-印度股初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserShareBlkRepo
//
//	@Description: 大宗交易服务
//	@param data
//	@param logger
//	@return biz.UserShareBlockOrderRepo
func NewUserShareBlkRepo(data *Data, logger log.Logger) biz.UserShareBlockOrderRepo {
	switch flags.CheckEnvironment {
	case flags.CheckShareBlk: // 大宗交易服务
		InitStockBlk(data)
	case flags.CheckAdminBlk: // 管理员大宗交易后台服务订阅
		InitAdminShareBlk(data)
	default:
		applogger.Debug("NewUserOrderRepo:请输入大宗交易服务初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

// NewUserBackendRepo
//
//	@Description: 后台-数据服务
//	@param data
//	@param logger
//	@return biz.UserBackendRepo
func NewUserBackendRepo(data *Data, logger log.Logger) biz.UserBackendRepo {
	switch flags.CheckEnvironment {
	case flags.CheckBackend: // 后台数据服务
	default:
		applogger.Debug("NewUserOrderRepo:请输入后台-后台初始化的环境变量.")
	}
	return &userOrderRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}