コード例 #1
0
        public async Task <IEnumerable <CryptoCurrencyDto> > GetAvailableCryptocurrencies()
        {
            // Call the external API using the product identifier as an URL parameter to
            string URL           = "https://data.messari.io/api/v2/assets";
            string urlParameters = "?fields=id,symbol,name,slug,metrics/market_data/price_usd,profile/general/overview/project_details";

            HttpClient client = new HttpClient();

            client.BaseAddress = new Uri(URL);

            // Add an Accept header for JSON format.
            client.DefaultRequestHeaders.Accept.Add(
                new MediaTypeWithQualityHeaderValue("application/json"));

            // List data response.
            var response = await client.GetAsync(urlParameters);

            if (response.IsSuccessStatusCode)
            {
                // Deserialize the response to a CryptoCurrencyDto model
                var cryptoCurrencies = await HttpResponseMessageExtensions.DeserializeJsonToList <CryptoCurrencyDto>(response, true);

                // Filter the list for BTC, ETH, USDT and XMR
                var filteredCryptoCurrencies = cryptoCurrencies.Where(c => c.Symbol == "BTC" || c.Symbol == "ETH" || c.Symbol == "USDT" || c.Symbol == "XMR").ToList();

                client.Dispose();

                return(filteredCryptoCurrencies);
            }
            else
            {
                throw new ApplicationException("Request failed to external API.");
            }
        }
コード例 #2
0
ファイル: ExchangeService.cs プロジェクト: sjofno17/cryptocop
        public async Task <Envelope <ExchangeDto> > GetExchanges(int pageNumber = 1)
        {
            HttpClient client = new HttpClient();

            // Call the external API with a paginated query and get all exchanges with fields required for the ExchangeDto model
            var getExhanges = "https://data.messari.io/api/v1/markets?page={pageNumber}&fields=id,exchange_name,exchange_slug,quote_asset_symbol,price_usd,last_trade_at";

            client.DefaultRequestHeaders.Accept.Clear();
            //client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

            var response = await client.GetAsync(getExhanges);

            // Deserialize the response to a list - I would advise to use the HttpResponseMessageExtensions to deserialize and flatten the response
            var responseFlat = await HttpResponseMessageExtensions.DeserializeJsonToList <ExchangeDto>(response, true);

            // Create an envelope and add the list to the envelope and return that

            /*var envelope = new Envelope<ExchangeDto>
             * {
             *  Items = new List<ExchangeDto>(responseFlat);
             *
             * };*/
            //return envelope;
            return(null);
        }
コード例 #3
0
        public void GetTypeResult_WhenGivenResponseWithWeatherDetailJson_ReturnWeatherDetail()
        {
            var response = new HttpResponseMessage(System.Net.HttpStatusCode.OK)
            {
                Content = new StringContent(TestHelper.GetWeatherDetailJson())
            };

            using (response)
            {
                var weatherDetail = HttpResponseMessageExtensions.GetTypedResult <WeatherDetail>(response);

                Assert.NotNull(weatherDetail);
                Assert.Equal("base", weatherDetail.Base);
            }
        }
コード例 #4
0
        public async Task <IEnumerable <CryptoCurrencyDto> > GetAvailableCryptocurrencies()
        {
            HttpClient client = new HttpClient();

            // Call the external API and get all cryptocurrencies with fields required for the CryptoCurrencyDto model
            var getCurrencies = "https://data.messari.io/api/v2/assets?fields=id,name,slug,symbol,metrics/market_data/price_usd,profile/general/overview/project_details";

            client.DefaultRequestHeaders.Accept.Clear();
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            var response = await client.GetAsync(getCurrencies);

            // Deserializes the response to a list - I would advise to use the HttpResponseMessageExtensions to deserialize and flatten the response.
            var responseFlat = await HttpResponseMessageExtensions.DeserializeJsonToList <CryptoCurrencyDto>(response, true);

            // Return a filtered list where only the available cryptocurrencies BitCoin (BTC), Ethereum (ETH), Tether (USDT) and Monero (XMR) are within the list
            return(responseFlat.Where(s => s.Symbol == "BTC" || s.Symbol == "ETH" || s.Symbol == "USDT" || s.Symbol == "XMR"));
        }
コード例 #5
0
        public async Task AddCartItem(string email, ShoppingCartItemInputModel shoppingCartItem)
        {
            var identifier = shoppingCartItem.ProductIdentifier;

            if (identifier.ToUpper() != "BTC" && identifier.ToUpper() != "ETH" && identifier.ToUpper() != "USDT" && identifier.ToUpper() != "XMR")
            {
                throw new ResourceNotFoundException("Invalid product identifier.");
            }

            // Call the external API using the product identifier as an URL parameter to
            string URL           = "https://data.messari.io/api/v1/assets/" + shoppingCartItem.ProductIdentifier + "/metrics";
            string urlParameters = "?fields=id,symbol,name,slug,market_data/price_usd";

            HttpClient client = new HttpClient();

            client.BaseAddress = new Uri(URL);

            // Add an Accept header for JSON format.
            client.DefaultRequestHeaders.Accept.Add(
                new MediaTypeWithQualityHeaderValue("application/json")
                );

            // List data response.
            var response = await client.GetAsync(urlParameters);

            if (response.IsSuccessStatusCode)
            {
                // Receive the current price in USD for this particular cryptocurrency
                // Deserialize the response to a CryptoCurrencyDto model
                var responseObject = await HttpResponseMessageExtensions.DeserializeJsonToObject <CryptoCurrencyDto>(response, true);

                client.Dispose();
                _shoppingCartRepository.AddCartItem(email, shoppingCartItem, responseObject.PriceInUsd);
            }
            else
            {
                throw new Exception("Response failed to external API.");
            }
        }
コード例 #6
0
        public async Task <Envelope <ExchangeDto> > GetExchanges(int pageNumber = 1)
        {
            // Call the external API using the product identifier as an URL parameter to
            string URL           = "https://data.messari.io/api/v1/markets";
            string urlParameters = "?fields=exchange_id,exchange_name,exchange_slug,quote_asset_symbol,price_usd,last_trade_at&page=" + pageNumber;

            HttpClient client = new HttpClient();

            client.BaseAddress = new Uri(URL);

            // Add an Accept header for JSON format.
            client.DefaultRequestHeaders.Accept.Add(
                new MediaTypeWithQualityHeaderValue("application/json"));

            // List data response.
            var response = await client.GetAsync(urlParameters);

            if (response.IsSuccessStatusCode)
            {
                // Deserialize the response to a ExchangeDto model
                var exchanges = await HttpResponseMessageExtensions.DeserializeJsonToList <ExchangeDto>(response, true);

                // Create the enveloper
                var envelope = new Envelope <ExchangeDto>
                {
                    Items      = exchanges,
                    PageNumber = pageNumber
                };

                client.Dispose();

                return(envelope);
            }
            else
            {
                throw new Exception("Request failed to external API.");
            }
        }
コード例 #7
0
        /// <remarks>
        /// Throws OperationCancelledException if <paramref name="cancel"/> is set.
        /// </remarks>
        private async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancel = default)
        {
            Guard.NotNull(nameof(request), request);

            // https://tools.ietf.org/html/rfc7230#section-2.7.1
            // A sender MUST NOT generate an "http" URI with an empty host identifier.
            var host = Guard.NotNullOrEmptyOrWhitespace($"{nameof(request)}.{nameof(request.RequestUri)}.{nameof(request.RequestUri.DnsSafeHost)}", request.RequestUri.DnsSafeHost, trim: true);

            // https://tools.ietf.org/html/rfc7230#section-2.6
            // Intermediaries that process HTTP messages (i.e., all intermediaries
            // other than those acting as tunnels) MUST send their own HTTP - version
            // in forwarded messages.
            request.Version = HttpProtocol.HTTP11.Version;

            if (TorSocks5Client != null && !TorSocks5Client.IsConnected)
            {
                TorSocks5Client?.Dispose();
                TorSocks5Client = null;
            }

            if (TorSocks5Client == null || !TorSocks5Client.IsConnected)
            {
                TorSocks5Client = new TorSocks5Client(TorSocks5EndPoint);
                await TorSocks5Client.ConnectAsync();

                await TorSocks5Client.HandshakeAsync(IsolateStream);

                await TorSocks5Client.ConnectToDestinationAsync(host, request.RequestUri.Port);

                Stream stream = TorSocks5Client.TcpClient.GetStream();
                if (request.RequestUri.Scheme == "https")
                {
                    SslStream sslStream;
                    // On Linux and OSX ignore certificate, because of a .NET Core bug
                    // This is a security vulnerability, has to be fixed as soon as the bug get fixed
                    // Details:
                    // https://github.com/dotnet/corefx/issues/21761
                    // https://github.com/nopara73/DotNetTor/issues/4
                    if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
                    {
                        sslStream = new SslStream(
                            stream,
                            leaveInnerStreamOpen: true);
                    }
                    else
                    {
                        sslStream = new SslStream(
                            stream,
                            leaveInnerStreamOpen: true,
                            userCertificateValidationCallback: (a, b, c, d) => true);
                    }

                    await sslStream
                    .AuthenticateAsClientAsync(
                        host,
                        new X509CertificateCollection(),
                        SslProtocols.Tls | SslProtocols.Tls11 | SslProtocols.Tls12,
                        checkCertificateRevocation : true);

                    stream = sslStream;
                }

                TorSocks5Client.Stream = stream;
            }
            cancel.ThrowIfCancellationRequested();

            // https://tools.ietf.org/html/rfc7230#section-3.3.2
            // A user agent SHOULD send a Content - Length in a request message when
            // no Transfer-Encoding is sent and the request method defines a meaning
            // for an enclosed payload body.For example, a Content - Length header
            // field is normally sent in a POST request even when the value is 0
            // (indicating an empty payload body).A user agent SHOULD NOT send a
            // Content - Length header field when the request message does not contain
            // a payload body and the method semantics do not anticipate such a
            // body.
            if (request.Method == HttpMethod.Post)
            {
                if (request.Headers.TransferEncoding.Count == 0)
                {
                    if (request.Content == null)
                    {
                        request.Content = new ByteArrayContent(new byte[] { });                         // dummy empty content
                        request.Content.Headers.ContentLength = 0;
                    }
                    else
                    {
                        if (request.Content.Headers.ContentLength == null)
                        {
                            request.Content.Headers.ContentLength = (await request.Content.ReadAsStringAsync()).Length;
                        }
                    }
                }
            }

            var requestString = await request.ToHttpStringAsync();

            var bytes = Encoding.UTF8.GetBytes(requestString);

            await TorSocks5Client.Stream.WriteAsync(bytes, 0, bytes.Length);

            await TorSocks5Client.Stream.FlushAsync();

            using (var httpResponseMessage = new HttpResponseMessage())
            {
                return(await HttpResponseMessageExtensions.CreateNewAsync(TorSocks5Client.Stream, request.Method));
            }
        }
コード例 #8
0
        public void GetTypeResult_WhenGivenNullArgument_ThrowArgumentNullException()
        {
            ArgumentNullException ex = Assert.Throws <ArgumentNullException>(() => HttpResponseMessageExtensions.GetTypedResult <WeatherDetail>(null));

            Assert.NotNull(ex);
        }