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.

513 lines
17 KiB

2 months ago
package memory
import (
"github.com/allegro/bigcache"
"github.com/shopspring/decimal"
"matchmaking-system/internal/pkg/utils"
)
var (
// 美股
ShareUsCache *bigcache.BigCache // 美股行情缓存
ShareUsChgMark *bigcache.BigCache // 美股买涨|买跌-涨跌幅标识
ShareUsClosePrice *bigcache.BigCache // 美股闭盘价格
ShareUsPriceSetUp *bigcache.BigCache // 美股设置盘前|盘后价格
ShareUsForcedClosure *bigcache.BigCache // 美股设置强平阈值
ShareUsFloating *bigcache.BigCache // 美股统计总浮动盈亏
// 印尼股
ShareIdnCache *bigcache.BigCache // 印尼股行情缓存
ShareIdnChgMark *bigcache.BigCache // 印尼股买涨|买跌-涨跌幅标识
ShareIdnClosePrice *bigcache.BigCache // 印尼闭盘价格
ShareIdnPriceSetUp *bigcache.BigCache // 印尼股设置盘前|盘后价格
ShareIdnForcedClosure *bigcache.BigCache // 印尼设置强平阈值
ShareIdnFloating *bigcache.BigCache // 印尼股统计总浮动盈亏
// 马股
ShareMysCache *bigcache.BigCache // 马股行情缓存
ShareMysChgMark *bigcache.BigCache // 马股买涨|买跌-涨跌幅标识
ShareMysClosePrice *bigcache.BigCache // 马股闭盘价格
ShareMysPriceSetUp *bigcache.BigCache // 马股设置盘前|盘后价格
ShareMysForcedClosure *bigcache.BigCache // 马股设置强平阈值
ShareMysFloating *bigcache.BigCache // 马股统计总浮动盈亏
// 泰股
ShareThaCache *bigcache.BigCache // 泰股行情缓存
ShareThaChgMark *bigcache.BigCache // 泰股买涨|买跌-涨跌幅标识
ShareThaClosePrice *bigcache.BigCache // 泰股闭盘价格
ShareThaPriceSetUp *bigcache.BigCache // 泰股设置盘前|盘后价格
ShareThaForcedClosure *bigcache.BigCache // 泰股设置强平阈值
ShareThaFloating *bigcache.BigCache // 泰股统计总浮动盈亏
// 印度股
ShareInrCache *bigcache.BigCache // 印度股行情缓存
ShareInrChgMark *bigcache.BigCache // 印度股买涨|买跌-涨跌幅标识
ShareInrClosePrice *bigcache.BigCache // 印度股闭盘价格
ShareInrPriceSetUp *bigcache.BigCache // 印度股设置盘前|盘后价格
ShareInrForcedClosure *bigcache.BigCache // 印度股设置强平阈值
ShareInrFloating *bigcache.BigCache // 印度股统计总浮动盈亏
// 新加坡股
ShareSgdCache *bigcache.BigCache // 新加坡股行情缓存
ShareSgdChgMark *bigcache.BigCache // 新加坡股买涨|买跌-涨跌幅标识
ShareSgdClosePrice *bigcache.BigCache // 新加坡股闭盘价格
ShareSgdPriceSetUp *bigcache.BigCache // 新加坡股设置盘前|盘后价格
ShareSgdForcedClosure *bigcache.BigCache // 新加坡股设置强平阈值
ShareSgdFloating *bigcache.BigCache // 新加坡股统计总浮动盈亏
// 港股
ShareHkdCache *bigcache.BigCache // 港股行情缓存
ShareHkdChgMark *bigcache.BigCache // 港股买涨|买跌-涨跌幅标识
ShareHkdClosePrice *bigcache.BigCache // 港股闭盘价格
ShareHkdPriceSetUp *bigcache.BigCache // 港股设置盘前|盘后价格
ShareHkdForcedClosure *bigcache.BigCache // 港股设置强平阈值
ShareHkdFloating *bigcache.BigCache // 港股统计总浮动盈亏
// 英股
ShareGbxCache *bigcache.BigCache // 英股行情缓存
ShareGbxChgMark *bigcache.BigCache // 英股买涨|买跌-涨跌幅标识
ShareGbxClosePrice *bigcache.BigCache // 英股闭盘价格
ShareGbxPriceSetUp *bigcache.BigCache // 英股设置盘前|盘后价格
ShareGbxForcedClosure *bigcache.BigCache // 英股设置强平阈值
ShareGbxFloating *bigcache.BigCache // 英股统计总浮动盈亏
// 德股
ShareEurCache *bigcache.BigCache // 德股行情缓存
ShareEurChgMark *bigcache.BigCache // 德股买涨|买跌-涨跌幅标识
ShareEurClosePrice *bigcache.BigCache // 德股闭盘价格
ShareEurPriceSetUp *bigcache.BigCache // 德股设置盘前|盘后价格
ShareEurForcedClosure *bigcache.BigCache // 德股设置强平阈值
ShareEurFloating *bigcache.BigCache // 德股统计总浮动盈亏
// 法股
ShareFurCache *bigcache.BigCache // 法股行情缓存
ShareFurChgMark *bigcache.BigCache // 法股买涨|买跌-涨跌幅标识
ShareFurClosePrice *bigcache.BigCache // 法股闭盘价格
ShareFurPriceSetUp *bigcache.BigCache // 法股设置盘前|盘后价格
ShareFurForcedClosure *bigcache.BigCache // 法股设置强平阈值
ShareFurFloating *bigcache.BigCache // 法股统计总浮动盈亏
// 巴西股
ShareBrlCache *bigcache.BigCache // 巴西股行情缓存
ShareBrlChgMark *bigcache.BigCache // 巴西股买涨|买跌-涨跌幅标识
ShareBrlClosePrice *bigcache.BigCache // 巴西股闭盘价格
ShareBrlPriceSetUp *bigcache.BigCache // 巴西股设置盘前|盘后价格
ShareBrlForcedClosure *bigcache.BigCache // 巴西股设置强平阈值
ShareBrlFloating *bigcache.BigCache // 巴西股统计总浮动盈亏
// 日本股
ShareJpyCache *bigcache.BigCache // 日本股行情缓存
ShareJpyChgMark *bigcache.BigCache // 日本股买涨|买跌-涨跌幅标识
ShareJpyClosePrice *bigcache.BigCache // 日本股闭盘价格
ShareJpyPriceSetUp *bigcache.BigCache // 日本股设置盘前|盘后价格
ShareJpyForcedClosure *bigcache.BigCache // 日本股设置强平阈值
ShareJpyFloating *bigcache.BigCache // 日本股统计总浮动盈亏
// 大宗交易
ShareBlkFloating *bigcache.BigCache // 大宗交易统计总浮动盈亏
)
// init
//
// @Description: 初始化股票-内存缓存
func init() {
// 股票-美股
ShareUsCache = NewBigCache()
ShareUsChgMark = NewBigCache()
ShareUsClosePrice = NewBigCache()
ShareUsPriceSetUp = NewBigCache()
ShareUsForcedClosure = NewBigCache()
ShareUsFloating = NewBigCache()
// 股票-印尼股
ShareIdnCache = NewBigCache()
ShareIdnChgMark = NewBigCache()
ShareIdnClosePrice = NewBigCache()
ShareIdnPriceSetUp = NewBigCache()
ShareIdnForcedClosure = NewBigCache()
ShareIdnFloating = NewBigCache()
// 股票-马股
ShareMysCache = NewBigCache()
ShareMysChgMark = NewBigCache()
ShareMysClosePrice = NewBigCache()
ShareMysPriceSetUp = NewBigCache()
ShareMysForcedClosure = NewBigCache()
ShareMysFloating = NewBigCache()
// 股票-泰股
ShareThaCache = NewBigCache()
ShareThaChgMark = NewBigCache()
ShareThaClosePrice = NewBigCache()
ShareThaPriceSetUp = NewBigCache()
ShareThaForcedClosure = NewBigCache()
ShareThaFloating = NewBigCache()
// 股票-印度股
ShareInrCache = NewBigCache()
ShareInrChgMark = NewBigCache()
ShareInrClosePrice = NewBigCache()
ShareInrPriceSetUp = NewBigCache()
ShareInrForcedClosure = NewBigCache()
ShareInrFloating = NewBigCache()
// 股票-新加坡股
ShareSgdCache = NewBigCache()
ShareSgdChgMark = NewBigCache()
ShareSgdClosePrice = NewBigCache()
ShareSgdPriceSetUp = NewBigCache()
ShareSgdForcedClosure = NewBigCache()
ShareSgdFloating = NewBigCache()
// 股票-港股
ShareHkdCache = NewBigCache()
ShareHkdChgMark = NewBigCache()
ShareHkdClosePrice = NewBigCache()
ShareHkdPriceSetUp = NewBigCache()
ShareHkdForcedClosure = NewBigCache()
ShareHkdFloating = NewBigCache()
// 股票-英股
ShareGbxCache = NewBigCache()
ShareGbxChgMark = NewBigCache()
ShareGbxClosePrice = NewBigCache()
ShareGbxPriceSetUp = NewBigCache()
ShareGbxForcedClosure = NewBigCache()
ShareGbxFloating = NewBigCache()
// 股票-德股
ShareEurCache = NewBigCache()
ShareEurChgMark = NewBigCache()
ShareEurClosePrice = NewBigCache()
ShareEurPriceSetUp = NewBigCache()
ShareEurForcedClosure = NewBigCache()
ShareEurFloating = NewBigCache()
// 股票-法股
ShareFurCache = NewBigCache()
ShareFurChgMark = NewBigCache()
ShareFurClosePrice = NewBigCache()
ShareFurPriceSetUp = NewBigCache()
ShareFurForcedClosure = NewBigCache()
ShareFurFloating = NewBigCache()
// 股票-巴西股
ShareBrlCache = NewBigCache()
ShareBrlChgMark = NewBigCache()
ShareBrlClosePrice = NewBigCache()
ShareBrlPriceSetUp = NewBigCache()
ShareBrlForcedClosure = NewBigCache()
ShareBrlFloating = NewBigCache()
// 股票-日本股
ShareJpyCache = NewBigCache()
ShareJpyChgMark = NewBigCache()
ShareJpyClosePrice = NewBigCache()
ShareJpyPriceSetUp = NewBigCache()
ShareJpyForcedClosure = NewBigCache()
ShareJpyFloating = NewBigCache()
// 大宗交易-(美股|泰股|马股|印尼股|印度股|新加坡股|港股|英股|德股|法股|日本股)
ShareBlkFloating = NewBigCache()
}
// GetShareUsCache
//
// @Description: 股票-美股市价(市价|盘前|盘后)
// @param key
// @return []byte
// @return error
func GetShareUsCache(key string) ([]byte, error) {
usP, err := ShareUsPriceSetUp.Get(key)
if err != nil || string(usP) == decimal.Zero.String() || len(utils.StrReplace(string(usP))) == 0 {
usS, errs := ShareUsCache.Get(key)
if errs != nil {
return []byte{}, err
}
return usS, nil
}
return usP, nil
}
func GetShareUsCacheWs(key string) ([]byte, error) {
usP, err := ShareUsCache.Get(key)
if err != nil || string(usP) == decimal.Zero.String() || len(utils.StrReplace(string(usP))) == 0 {
return []byte{}, err
}
return usP, nil
}
// GetShareThaCache
//
// @Description: 股票-泰股市价(市价|盘前|盘后)
// @param key
// @return []byte
// @return error
func GetShareThaCache(key string) ([]byte, error) {
thaP, err := ShareThaPriceSetUp.Get(key)
if err != nil || string(thaP) == decimal.Zero.String() || len(utils.StrReplace(string(thaP))) == 0 {
thaS, errs := ShareThaCache.Get(key)
if errs != nil {
return []byte{}, err
}
return thaS, nil
}
return thaP, nil
}
func GetShareThaCacheWs(key string) ([]byte, error) {
thaP, err := ShareThaCache.Get(key)
if err != nil || string(thaP) == decimal.Zero.String() || len(utils.StrReplace(string(thaP))) == 0 {
return []byte{}, err
}
return thaP, nil
}
// GetShareIdnCache
//
// @Description: 股票-印尼股市价(市价|盘前|盘后)
// @param key
// @return []byte
// @return error
func GetShareIdnCache(key string) ([]byte, error) {
idnP, err := ShareIdnPriceSetUp.Get(key)
if err != nil || string(idnP) == decimal.Zero.String() || len(utils.StrReplace(string(idnP))) == 0 {
idnS, errs := ShareIdnCache.Get(key)
if errs != nil {
return []byte{}, err
}
return idnS, nil
}
return idnP, nil
}
func GetShareIdnCacheWs(key string) ([]byte, error) {
idnP, err := ShareIdnCache.Get(key)
if err != nil || string(idnP) == decimal.Zero.String() || len(utils.StrReplace(string(idnP))) == 0 {
return []byte{}, err
}
return idnP, nil
}
// GetShareMysCache
//
// @Description: 股票-马股市价(市价|盘前|盘后)
// @param key
// @return []byte
// @return error
func GetShareMysCache(key string) ([]byte, error) {
mysP, err := ShareMysPriceSetUp.Get(key)
if err != nil || string(mysP) == decimal.Zero.String() || len(utils.StrReplace(string(mysP))) == 0 {
mysS, errs := ShareMysCache.Get(key)
if errs != nil {
return []byte{}, err
}
return mysS, nil
}
return mysP, nil
}
func GetShareMysCacheWs(key string) ([]byte, error) {
mysP, err := ShareMysCache.Get(key)
if err != nil || string(mysP) == decimal.Zero.String() || len(utils.StrReplace(string(mysP))) == 0 {
return []byte{}, err
}
return mysP, nil
}
// GetShareInrCache
//
// @Description: 股票-印度股市价(市价|盘前|盘后)
// @param key
// @return []byte
// @return error
func GetShareInrCache(key string) ([]byte, error) {
inrP, err := ShareInrPriceSetUp.Get(key)
if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
inrS, errs := ShareInrCache.Get(key)
if errs != nil {
return []byte{}, err
}
return inrS, nil
}
return inrP, nil
}
func GetShareInrCacheWs(key string) ([]byte, error) {
inrP, err := ShareInrCache.Get(key)
if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
return []byte{}, err
}
return inrP, nil
}
// GetShareSgdCache
//
// @Description: 股票-新加坡股市价(市价|盘前|盘后)
// @param key
// @return []byte
// @return error
func GetShareSgdCache(key string) ([]byte, error) {
inrP, err := ShareSgdPriceSetUp.Get(key)
if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
inrS, errs := ShareSgdCache.Get(key)
if errs != nil {
return []byte{}, err
}
return inrS, nil
}
return inrP, nil
}
func GetShareSgdCacheWs(key string) ([]byte, error) {
inrP, err := ShareSgdCache.Get(key)
if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
return []byte{}, err
}
return inrP, nil
}
// GetShareHkdCache
//
// @Description: 股票-港股市价(市价|盘前|盘后)
// @param key
// @return []byte
// @return error
func GetShareHkdCache(key string) ([]byte, error) {
inrP, err := ShareHkdPriceSetUp.Get(key)
if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
inrS, errs := ShareHkdCache.Get(key)
if errs != nil {
return []byte{}, err
}
return inrS, nil
}
return inrP, nil
}
func GetShareHkdCacheWs(key string) ([]byte, error) {
inrP, err := ShareHkdCache.Get(key)
if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
return []byte{}, err
}
return inrP, nil
}
// GetShareGbxCache
//
// @Description: 股票-英股市价(市价|盘前|盘后)
// @param key
// @return []byte
// @return error
func GetShareGbxCache(key string) ([]byte, error) {
inrP, err := ShareGbxPriceSetUp.Get(key)
if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
inrS, errs := ShareGbxCache.Get(key)
if errs != nil {
return []byte{}, err
}
return inrS, nil
}
return inrP, nil
}
func GetShareGbxCacheWs(key string) ([]byte, error) {
inrP, err := ShareGbxCache.Get(key)
if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
return []byte{}, err
}
return inrP, nil
}
// GetShareEurCache
//
// @Description: 股票-德股市价(市价|盘前|盘后)
// @param key
// @return []byte
// @return error
func GetShareEurCache(key string) ([]byte, error) {
inrP, err := ShareEurPriceSetUp.Get(key)
if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
inrS, errs := ShareEurCache.Get(key)
if errs != nil {
return []byte{}, err
}
return inrS, nil
}
return inrP, nil
}
func GetShareEurCacheWs(key string) ([]byte, error) {
inrP, err := ShareEurCache.Get(key)
if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
return []byte{}, err
}
return inrP, nil
}
// GetShareFurCache
//
// @Description: 股票-法股市价(市价|盘前|盘后)
// @param key
// @return []byte
// @return error
func GetShareFurCache(key string) ([]byte, error) {
inrP, err := ShareFurPriceSetUp.Get(key)
if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
inrS, errs := ShareFurCache.Get(key)
if errs != nil {
return []byte{}, err
}
return inrS, nil
}
return inrP, nil
}
func GetShareFurCacheWs(key string) ([]byte, error) {
inrP, err := ShareFurCache.Get(key)
if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
return []byte{}, err
}
return inrP, nil
}
// GetShareBrlCache
//
// @Description: 股票-巴西股市价(市价|盘前|盘后)
// @param key
// @return []byte
// @return error
func GetShareBrlCache(key string) ([]byte, error) {
inrP, err := ShareBrlPriceSetUp.Get(key)
if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
inrS, errs := ShareBrlCache.Get(key)
if errs != nil {
return []byte{}, err
}
return inrS, nil
}
return inrP, nil
}
func GetShareBrlCacheWs(key string) ([]byte, error) {
inrP, err := ShareBrlCache.Get(key)
if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
return []byte{}, err
}
return inrP, nil
}
// GetShareJpyCache
//
// @Description: 股票-日股市价(市价|盘前|盘后)
// @param key
// @return []byte
// @return error
func GetShareJpyCache(key string) ([]byte, error) {
inrP, err := ShareJpyPriceSetUp.Get(key)
if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
inrS, errs := ShareJpyCache.Get(key)
if errs != nil {
return []byte{}, err
}
return inrS, nil
}
return inrP, nil
}
func GetShareJpyCacheWs(key string) ([]byte, error) {
inrP, err := ShareJpyCache.Get(key)
if err != nil || string(inrP) == decimal.Zero.String() || len(utils.StrReplace(string(inrP))) == 0 {
return []byte{}, err
}
return inrP, nil
}