public async Task <ExchangeInfo> ExchangeInfo()
        {
            try
            {
                var response =
                    await _downloader.Get("exchangeInfo", new Maybe <FormUrlEncodedContent>());

                return(JsonConvert.DeserializeObject <ExchangeInfo>(response));
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        public async Task <GenericResponse> HistoDay(string fromSymbol, string toSymbol,
                                                     Maybe <string> exchange,
                                                     Maybe <int> aggregate, Maybe <int> limit, Maybe <int> toTs, Maybe <string> allData)
        {
            try
            {
                var parameters = new Dictionary <string, string>()
                {
                    { "fsym", fromSymbol },
                    { "tsym", toSymbol }
                };

                if (exchange.Any())
                {
                    parameters.Add("e", exchange.Single());
                }

                if (aggregate.Any())
                {
                    parameters.Add("aggregate", aggregate.Single().ToString());
                }

                if (limit.Any())
                {
                    parameters.Add("limit", limit.Single().ToString());
                }

                if (toTs.Any())
                {
                    parameters.Add("toTs", toTs.Single().ToString());
                }

                if (allData.Any())
                {
                    parameters.Add("allData", allData.Single());
                }

                var content = new Maybe <FormUrlEncodedContent>(
                    new FormUrlEncodedContent(parameters));

                var response = await downloader.Get("histoday", content);

                return(JsonConvert.DeserializeObject <GenericResponse>(response));
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        internal async Task <TickerDto> Ticker(string symbol)
        {
            try
            {
                var param = new FormUrlEncodedContent(new Dictionary <string, string>()
                {
                    { "symbol", symbol },
                    { "api_key", _mxcSecrets.ApiKey }
                });

                var response = await _downloader.Get("market/ticker", new Maybe <FormUrlEncodedContent>(param));

                return(JsonConvert.DeserializeObject <TickerDto>(response));
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        public async Task <Markets> Markets()
        {
            try
            {
                var result = await _downloader.Get("getmarkets", new Maybe <FormUrlEncodedContent>());

                return(JsonConvert.DeserializeObject <Markets>(result, _jsonSettings));
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        internal async Task <OrderBookDto> OrderBook(string market, int limit, int side, int offset = 0)
        {
            var param = new FormUrlEncodedContent(new Dictionary <string, string>()
            {
                { "market", market },
                { "limit", limit.ToString() },
                { "side", side.ToString() },
                { "offset", offset.ToString() },
            });


            var response = await _downloader.Get("order.book", new Maybe <FormUrlEncodedContent>(param));

            return(JsonConvert.DeserializeObject <OrderBookDto>(response));
        }
Exemple #6
0
 public async Task <IList <Download> > Get()
 {
     return(await _downloadData.Get());
 }
Exemple #7
0
 public async Task <Download> Get(Guid torrentId, String path)
 {
     return(await _downloadData.Get(torrentId, path));
 }