public Task <GetMarketInfoResponse> GetMarketInfoAsync(MarketRequest request)
{
try
{
var data = _externalMarketSettingsAccessor.GetExternalMarketSettings(request.Market);
if (data == null)
{
return(new GetMarketInfoResponse().AsTask());
}
return(new GetMarketInfoResponse
{
Info = new ExchangeMarketInfo()
{
Market = data.Market,
BaseAsset = data.BaseAsset,
QuoteAsset = data.QuoteAsset,
MinVolume = data.MinVolume,
PriceAccuracy = data.PriceAccuracy,
VolumeAccuracy = data.VolumeAccuracy
}
}.AsTask());
}
catch (Exception ex)
{
_logger.LogError(ex, "Cannot get FTX GetMarketInfo: {marketText}", request.Market);
throw;
}
}
public async Task <MarketResponse> GetMarketAsync(MarketRequest request)
{
if (String.IsNullOrEmpty(request.Pair))
{
throw new ArgumentNullException(nameof(request.Pair));
}
var content = await CallAsync <ResponseModel>(HttpMethod.Get, BuildUrl(_settings.PublicUrl, $"{request.Pair}/open/tick"));
if (!(bool)content.Data.trading)
{
return(null);
}
dynamic data = content.Data;
return(new MarketResponse
{
LastPrice = data.lastDealPrice,
AskPrice = data.buy,
BidPrice = data.sell,
Volume = data.vol,
Low = ((decimal?)data.low).GetValueOrDefault(),
High = ((decimal?)data.high).GetValueOrDefault()
});
}
protected void AddSecurities(Securities sec)
{
if (!secDict.ContainsKey(sec.Symbol))
{
_log.Debug("订阅{0}股票价格", sec.Symbol);
secDict.Add(sec.Symbol, sec);
String path1 = String.Format("/user/{0}", ConstantsHelper.AKKA_PATH_MARKET_MANAGER);
var marketActor = Context.ActorSelection(path1);
// 增加一个关注的股票
MarketRequest request = new MarketRequest()
{
Type = MarketRequest.RequestType.ADD_SECURITIES, Body = sec
};
marketActor.Tell(request);
//var ret = marketActor.Ask<Object>(request, TimeSpan.FromSeconds(2));
//ret.Wait();
//
String path = String.Format("/user/{0}/{1}", ConstantsHelper.AKKA_PATH_MARKET_MANAGER, sec.Symbol);
var secActor = Context.ActorSelection(path);
SecuritiesQuotationRequest req = new SecuritiesQuotationRequest()
{
Type = SecuritiesQuotationRequest.RequestType.WATCH_QUOTEDATA,
Body = Desc.Id
};
secActor.Tell(req);
symbolPriceActors.Add(sec.Symbol, secActor);
}
}
protected override Dictionary <string, decimal> GetAllPrice()
{
try {
Dictionary <string, decimal> dic = new Dictionary <string, decimal>();
MarketRequest marketRequest = coinealAPI.EnSendRequestContent <MarketRequest>(ApiUrlList.API_Market);
var l = marketRequest.data.Where(S => S.Key.Contains("usdt")).ToDictionary(S => S.Key, S => S.Value);
foreach (var item in l)
{
if (item.Key.Length == 7)
{
dic.Add(item.Key.Insert(3, "_"), item.Value);
}
else if (item.Key.Length == 8)
{
dic.Add(item.Key.Insert(4, "_"), item.Value);
}
else
{
dic.Add(item.Key.Insert(5, "_"), item.Value);
}
}
return(dic);
}
catch (Exception e)
{
Alert(e.ToString());
return(null);
}
}
static void RefreshVitShopData()
{
MarketRequest req = new MarketRequest();
req.Category = Category.Vit;
GameEvents.NetWorkEvents.SendAsyncMsg.SafeInvoke(req);
}
public Market[] Get(MarketRequest request)
{
Market[] markets;
if (request.Sport == "FOOTBALL")
{
var footballGen = new FootballMarketGenerator();
return(footballGen.GetMarkets(request.Fixture));
}
else if (request.Sport == "tennis")
{
var tennisGen = new TennisMarketGenerator();
var tennisMarkets = tennisGen.GetMarkets(request.Fixture);
markets = new Market[tennisMarkets.Count];
for (var i = 0; i < tennisMarkets.Count; i++)
{
markets[i] = tennisMarkets.Skip(i).Take(1).First();
}
}
else
{
throw new Exception();
}
return(markets);
}
public Task <HasSymbolResponse> HasSymbolAsync(MarketRequest request)
{
return(Task.FromResult(new HasSymbolResponse()
{
Result = _manager.HasSymbol(request.Market)
}));
}
private void requestShopData(bool isAsyn, Category cat)
{
MarketRequest request = new MarketRequest();
request.Category = cat;
GameEvents.NetWorkEvents.SendAsyncMsg.SafeInvoke(request);
}
public Task <GetOrderBookResponse> GetOrderBookAsync(MarketRequest request)
{
var result = _manager.GetOrderBook(request.Market);
return(Task.FromResult(new GetOrderBookResponse()
{
OrderBook = result
}));
}
private void requestData()
{
#if Test
MarketResponse res = ShopHelper.getShopDataTest(cate);
OnResponse(res);
#else
MarketRequest request = new MarketRequest();
request.Category = cate;
GameEvents.NetWorkEvents.SendAsyncMsg.SafeInvoke(request);
#endif
}
public async Task <MarketResponse> GetMarketAsync(MarketRequest request)
{
if (String.IsNullOrEmpty(request.Pair))
{
throw new ArgumentNullException(nameof(request.Pair));
}
var content = await CallAsync <dynamic>(HttpMethod.Get, BuildUrl(_settings.PublicUrl, $"instrument?symbol={request.Pair}"));
return(new MarketResponse {
LastPrice = content[0].lastPrice
});
}
public Task <GetMarketInfoResponse> GetMarketInfoAsync(MarketRequest request)
{
if (MarketInfo.TryGetValue(request.Market, out var info))
{
return(Task.FromResult(new GetMarketInfoResponse()
{
Info = info
}));
}
return(Task.FromResult(new GetMarketInfoResponse()
{
Info = null
}));
}
public async Task <MarketResponse> GetMarketAsync(MarketRequest request)
{
if (String.IsNullOrEmpty(request.Pair))
{
throw new ArgumentNullException(nameof(request.Pair));
}
var content = await CallAsync <dynamic>(HttpMethod.Get, BuildUrl(_settings.PublicUrl, $"ticker.do?symbol={request.Pair}"));
return(new MarketResponse
{
LastPrice = content.ticker.last,
AskPrice = content.ticker.buy,
BidPrice = content.ticker.sell,
High = content.ticker.high,
Low = content.ticker.low,
Volume = content.ticker.vol
});
}
public async Task <MarketResponse> GetMarketAsync(MarketRequest request)
{
if (String.IsNullOrEmpty(request.Pair))
{
throw new ArgumentNullException(nameof(request.Pair));
}
var content = await CallAsync <dynamic>(HttpMethod.Get, BuildUrl(_settings.PublicUrl, $"market/detail/merged?symbol={request.Pair}"));
return(new MarketResponse
{
LastPrice = content.tick.close,
AskPrice = content.tick.ask[0],
BidPrice = content.tick.bid[0],
Volume = content.tick.vol,
High = content.tick.high,
Low = content.tick.low
});
}
public async Task <MarketResponse> GetMarketAsync(MarketRequest request)
{
if (String.IsNullOrEmpty(request.Pair))
{
throw new ArgumentNullException(nameof(request.Pair));
}
var content = await CallAsync <dynamic>(HttpMethod.Get, BuildUrl(_settings.PublicUrl, $"pubticker/{request.Pair}"));
return(new MarketResponse
{
LastPrice = content.last_price,
AskPrice = content.ask,
BidPrice = content.bid,
Volume = content.volume,
High = content.high,
Low = content.low
});
}
public Task <OrderEntry[]> RequestMarketCheck(string itemName)
{
var request = new MarketRequest(itemName, false);
this.pendingRequests.Enqueue(request);
return(Task.Run(() =>
{
var doneEvent = new ManualResetEvent(false);
OrderEntry[] data = null;
using var _ = request.UpdateSubject.Subscribe(md =>
{
data = md.orders;
doneEvent.Set();
});
doneEvent.WaitOne();
Debug.Assert(data != null, "Market data cannot be null");
return data;
}));
}
public Task <(string description, long scrapValue, OrderEntry[] orders)> RequestMarketCheckWithDescription(
string itemName)
{
var request = new MarketRequest(itemName, true);
this.pendingRequests.Enqueue(request);
return(Task.Run(() =>
{
var doneEvent = new ManualResetEvent(false);
(string description, long scrapValue, OrderEntry[] orders)? data = null;
using var subscribe = request.UpdateSubject.Subscribe(md =>
{
data = md;
doneEvent.Set();
});
doneEvent.WaitOne();
Debug.Assert(data.HasValue, "Market data cannot be null");
return data.Value;
}));
}
public async Task <MarketResponse> GetMarketAsync(MarketRequest request)
{
if (String.IsNullOrEmpty(request.Pair))
{
throw new ArgumentNullException(nameof(request.Pair));
}
var content = await CallAsync <dynamic>(HttpMethod.Get, BuildUrl(_settings.PublicUrl, $"ticker/{request.Pair}?ignore_invalid=1"));
dynamic data = content[request.Pair];
return(new MarketResponse
{
LastPrice = data.last,
Volume = data.vol,
AskPrice = data.buy,
BidPrice = data.sell,
High = data.high,
Low = data.low
});
}
public async Task <MarketResponse> GetMarketAsync(MarketRequest request)
{
if (String.IsNullOrEmpty(request.Pair))
{
throw new ArgumentNullException(nameof(request.Pair));
}
var content = await CallAsync <Dictionary <string, dynamic> >(HttpMethod.Get, BuildUrl(_settings.PublicUrl, "ticker"));
dynamic item = content[request.Pair];
return(new MarketResponse
{
LastPrice = item.last_trade,
High = item.high,
Low = item.low,
Volume = item.vol,
AskPrice = item.buy_price,
BidPrice = item.sell_price
});
}
public async Task <MarketResponse> GetMarketAsync(MarketRequest request)
{
if (String.IsNullOrEmpty(request.Pair))
{
throw new ArgumentNullException(nameof(request.Pair));
}
var content = await CallAsync <dynamic>(HttpMethod.Get, BuildUrl(_settings.PublicUrl, $"GetMarket/{request.Pair}"));
var response = new MarketResponse
{
AskPrice = content.Data.AskPrice,
BidPrice = content.Data.BidPrice,
High = content.Data.High,
Low = content.Data.Low,
LastPrice = content.Data.LastPrice,
Volume = content.Data.Volume
};
return(response);
}
public void GetMarketplace()
{
Debug.Log("Starts get");
while (File.Exists("Passout.json"))
{
File.Delete("Passout.json");
}
MarketRequest req = new MarketRequest();
string message = JsonUtility.ToJson(req);
using (FileStream fs = File.Create("Passin.json"))
{
byte[] info = new UTF8Encoding(true).GetBytes(message);
fs.Write(info, 0, info.Length);
fs.Flush();
fs.Close();
fs.Dispose();
}
StartCoroutine(ReadFile());
}
public static void btnTransPanel(string panelName)
{
if (panelName.Equals(UIDefine.UI_MAIL))
{
EngineCoreEvents.UIEvent.ShowUIEvent.SafeInvoke(UIDefine.UI_MAIL);
}
else if (panelName.Equals(UIDefine.UI_BAG))
{
//CSPlayerPropRequest msg_prop = new CSPlayerPropRequest();
//GameEvents.NetWorkEvents.SendHalfSyncMsg.SafeInvoke(msg_prop);
//EngineCoreEvents.UIEvent.ShowUIEvent.SafeInvoke(UIDefine.UI_BAG);
EngineCoreEvents.UIEvent.ShowUIByOther.SafeInvoke(UIDefine.UI_BAG, UIDefine.UI_GAMEENTRY);
}
#if OFFICER_SYS
else if (panelName.Equals(UIDefine.UI_POLICE))
{
EngineCoreEvents.UIEvent.ShowUIEvent.SafeInvoke(UIDefine.UI_POLICE);
}
#endif
else if (panelName.Equals(UIDefine.UI_EVENT_INGAME_ENTRY))
{
CSEventDropInfoRequest req = new CSEventDropInfoRequest();
#if TEST
req.EventId = 2;
#endif
#if !NETWORK_SYNC || UNITY_EDITOR
GameEvents.NetWorkEvents.SendAsyncMsg.SafeInvoke(req);
#else
GameEvents.NetWorkEvents.SendMsg.SafeInvoke(req);
#endif
}
else if (panelName.Equals(UIDefine.UI_SHOP))
{
if (ShopHelper.IsShopDataAvaliable(Category.Common))
{
ShopHelper.OpenShop(Category.Common);
}
else
{
MessageHandler.RegisterMessageHandler(MessageDefine.MarketResponse, GameEntryHelper.TransPanel);
MarketRequest req = new MarketRequest();
req.Category = Category.Common;
GameEvents.NetWorkEvents.SendAsyncMsg.SafeInvoke(req);
}
}
else if (panelName.Equals(UIDefine.UI_SCENETALK))
{
TalkUIHelper.OnStartTalk(3);
}
else if (panelName.Equals(UIDefine.UI_SLOTS))
{
EngineCoreEvents.UIEvent.ShowUIEvent.SafeInvoke(UIDefine.UI_ACTIVITY);
}
else if (panelName.Equals(UIDefine.UI_ACHIEVEMENT))
{
EngineCoreEvents.UIEvent.ShowUIEvent.SafeInvoke(UIDefine.UI_ACHIEVEMENT);
}
else if (panelName.Equals(UIDefine.UI_FRIEND))
{
EngineCoreEvents.UIEvent.ShowUIEvent.SafeInvoke(UIDefine.UI_FRIEND);
}
else if (panelName == UIDefine.UI_CHAPTER)
{
EngineCoreEvents.UIEvent.ShowUIEvent.SafeInvoke(UIDefine.UI_CHAPTER);
}
else if (panelName.Equals(UIDefine.UI_COMBINE))
{
EngineCoreEvents.UIEvent.ShowUIEvent.SafeInvoke(UIDefine.UI_COMBINE);
}
}
public async Task <MarketResponse> GetMarket(MarketRequest request)
{
var query = request.Hours.HasValue ? $"/{request.TradePairId}/{request.Hours}" : $"/{request.TradePairId}";
return(await GetResult <MarketResponse>(PublicApiCall.GetMarket, query));
}
public async Task <List <Market> > GetMarketsAsync(MarketRequest request)
{
return(await this.httpClient.GetAsync <List <Market> >($"{baseUrl}/api/v1/markets{Query(request)}"));
}
public List <Market> GetMarkets(MarketRequest request) => GetMarketsAsync(request).GetAwaiter().GetResult();
