Esempio n. 1
0
        private async Task <T> GetValuesAsync <T>(string resourceUri, object parametersAsAnonymousObject) where T : class
        {
            var requestUrl = MakeRequestUri(resourceUri);

            var request = new HttpRequest(HttpMethod.Post, requestUrl);

            request.AddBody(parametersAsAnonymousObject);

            return(await SendAsync <T>(request));
        }
Esempio n. 2
0
        private IAsyncEnumerator <byte[]> HandleHttpRequest(StreamReader reader)
        {
            return(new AsyncEnumerator <byte[]>(async yield =>
            {
                while (true)
                {
                    var requestLine = await reader.ReadLineAsync();
                    if (string.IsNullOrWhiteSpace(requestLine))
                    {
                        yield.Break();
                    }

                    var request = new HttpRequest(requestLine);
                    while (true)
                    {
                        var line = await reader.ReadLineAsync();
                        if (string.IsNullOrEmpty(line))
                        {
                            if (request.Headers.TryGetValue("Content-Length", out string contentLength))
                            {
                                var length = int.Parse(contentLength);
                                var bytes = new List <char>(length);
                                while (bytes.Count < length)
                                {
                                    var buffer = new char[length];
                                    var readCount = await reader.ReadAsync(buffer, 0, length);
                                    bytes.AddRange(buffer.Take(readCount));
                                }

                                request.AddBody(bytes.Select(c => (byte)c));
                            }

                            break;
                        }

                        request.AddHeader(line);
                    }
                    Log.D($"[{Identifier}] {request.Method} {request.Path}");

                    var response = await((IHttpHandler)Handler).HandleRequest(request);
                    await yield.ReturnAsync(response.ToBytes());

                    if (response.Headers.TryGetValue("Connection", out object connection))
                    {
                        if (connection.ToString().ToLower() == "close")
                        {
                            yield.Break();
                        }
                    }
                }
            }));
        }
Esempio n. 3
0
        public async Task <ItemAddedWrapper> AddItemAsync(string uri)
        {
            var requestUri = MakeRequestUri("v3/add");
            var encodedUri = HttpUtility.UrlEncode(uri);

            var request = new HttpRequest(HttpMethod.Post, requestUri);

            request.AddBody(new
            {
                consumer_key = _consumerKey,
                access_token = _accessToken,
                url          = encodedUri
            });

            var response = await SendAsync <ItemAddedWrapper>(request);

            return(response);
        }
Esempio n. 4
0
        private void BuildBody(T parameter, HttpRequest request)
        {
            var bodies = Components.Where(c => c.Value.Attribute is HttpBodyComponentAttribute).ToArray();

            if (bodies.Any())
            {
                var body  = bodies.First();
                var value = GetValue(parameter, body.Key);
                if (((HttpBodyComponentAttribute)body.Value.Attribute).ContentType == HttpContentType.Binary)
                {
                    if (value is Stream stream)
                    {
                        request.AddBody(stream);
                    }
                }
                else
                {
                    request.AddJsonBody(value);
                }
            }
        }