/// <summary> /// Call api asynchronous and return response of specified type asynchronously. /// </summary> /// <param name="method">HTTP method.</param> /// <param name="url">Url for api call.</param> /// <param name="parameters">Parameters for api call.</param> /// <param name="file">File to upload (must be null for non-uploading actions).</param> /// <param name="extraHeaders">Extra headers.</param> /// <param name="cancellationToken">Cancellation token.</param> /// <returns>Return response of specified type.</returns> /// <typeparam name="T">Type of the parsed response.</typeparam> internal virtual Task <T> CallApiAsync <T>( HttpMethod method, string url, BaseParams parameters, FileDescription file, Dictionary <string, string> extraHeaders = null, CancellationToken?cancellationToken = null) where T : BaseResult, new() { parameters?.Check(); var callParams = (method == HttpMethod.PUT || method == HttpMethod.POST) ? parameters?.ToParamsDictionary() : null; return(CallAndParseAsync <T>(method, url, callParams, file, extraHeaders, cancellationToken)); }
/// <summary> /// Call the Cloudinary API and parse HTTP response. /// </summary> /// <typeparam name="T">Type of the response.</typeparam> /// <param name="method">HTTP method.</param> /// <param name="url">A generated URL.</param> /// <param name="parameters">Cloudinary parameters to add to the API call.</param> /// <param name="file">(Optional) Add file to the body of the API call.</param> /// <param name="extraHeaders">(Optional) Headers to add to the request.</param> /// <returns>Instance of the parsed response from the cloudinary API.</returns> public T CallAndParse <T>( HttpMethod method, string url, SortedDictionary <string, object> parameters, FileDescription file, Dictionary <string, string> extraHeaders = null) where T : BaseResult, new() { using (var response = Call( method, url, parameters, file, extraHeaders)) { return(Parse <T>(response)); } }
/// <summary> /// Prepares request body to be sent on custom call to Cloudinary API. /// </summary> /// <param name="request">HTTP request to alter.</param> /// <param name="method">HTTP method of call.</param> /// <param name="parameters">Dictionary of call parameters.</param> /// <param name="file">File to upload.</param> /// <param name="extraHeaders">(Optional) Headers to add to the request.</param> /// <returns>Prepared HTTP request.</returns> internal HttpRequestMessage PrepareRequestBody( HttpRequestMessage request, HttpMethod method, SortedDictionary <string, object> parameters, FileDescription file, Dictionary <string, string> extraHeaders = null) { PrePrepareRequestBody(request, method, extraHeaders); if (ShouldPrepareContent(method, parameters)) { SetChunkedEncoding(request); PrepareRequestContent(request, parameters, file, extraHeaders); } return(request); }
/// <summary> /// Makes custom call to Cloudinary API. /// </summary> /// <param name="method">HTTP method of call.</param> /// <param name="url">URL to call.</param> /// <param name="parameters">Dictionary of call parameters (can be null).</param> /// <param name="file">File to upload (must be null for non-uploading actions).</param> /// <param name="extraHeaders">Headers to add to the request.</param> /// <returns>HTTP response on call.</returns> public HttpResponseMessage Call( HttpMethod method, string url, SortedDictionary <string, object> parameters, FileDescription file, Dictionary <string, string> extraHeaders = null) { using (var request = requestBuilder(url)) { PrepareRequestBody(request, method, parameters, file, extraHeaders); var cancellationToken = GetDefaultCancellationToken(); return(Client .SendAsync(request, cancellationToken) .GetAwaiter() .GetResult()); } }
/// <summary> /// Prepares request body to be sent on custom asynchronous call to Cloudinary API. /// </summary> /// <param name="request">HTTP request to alter.</param> /// <param name="method">HTTP method of call.</param> /// <param name="parameters">Dictionary of call parameters.</param> /// <param name="file">File to upload.</param> /// <param name="extraHeaders">(Optional) Headers to add to the request.</param> /// <param name="cancellationToken">(Optional) Cancellation token.</param> /// <returns>Prepared HTTP request.</returns> internal async Task <HttpRequestMessage> PrepareRequestBodyAsync( HttpRequestMessage request, HttpMethod method, SortedDictionary <string, object> parameters, FileDescription file, Dictionary <string, string> extraHeaders = null, CancellationToken?cancellationToken = null) { PrePrepareRequestBody(request, method, extraHeaders); if (ShouldPrepareContent(method, parameters)) { SetChunkedEncoding(request); await PrepareRequestContentAsync(request, parameters, file, extraHeaders, cancellationToken); } return(request); }
/// <summary> /// Call the Cloudinary API and parse HTTP response asynchronously. /// </summary> /// <typeparam name="T">Type of the response.</typeparam> /// <param name="method">HTTP method.</param> /// <param name="url">A generated URL.</param> /// <param name="parameters">Cloudinary parameters to add to the API call.</param> /// <param name="file">(Optional) Add file to the body of the API call.</param> /// <param name="extraHeaders">Headers to add to the request.</param> /// <param name="cancellationToken">(Optional) Cancellation token.</param> /// <returns>Instance of the parsed response from the cloudinary API.</returns> public async Task <T> CallAndParseAsync <T>( HttpMethod method, string url, SortedDictionary <string, object> parameters, FileDescription file, Dictionary <string, string> extraHeaders = null, CancellationToken?cancellationToken = null) where T : BaseResult, new() { using (var response = await CallAsync( method, url, parameters, file, extraHeaders, cancellationToken).ConfigureAwait(false)) { return(await ParseAsync <T>(response).ConfigureAwait(false)); } }
/// <summary> /// Makes custom call to Cloudinary API asynchronously. /// </summary> /// <param name="method">HTTP method of call.</param> /// <param name="url">URL to call.</param> /// <param name="parameters">Dictionary of call parameters (can be null).</param> /// <param name="file">File to upload (must be null for non-uploading actions).</param> /// <param name="extraHeaders">Headers to add to the request.</param> /// <param name="cancellationToken">(Optional) Cancellation token.</param> /// <returns>HTTP response on call.</returns> public async Task <HttpResponseMessage> CallAsync( HttpMethod method, string url, SortedDictionary <string, object> parameters, FileDescription file, Dictionary <string, string> extraHeaders = null, CancellationToken?cancellationToken = null) { using (var request = await PrepareRequestBodyAsync( requestBuilder(url), method, parameters, file, extraHeaders, cancellationToken).ConfigureAwait(false)) { var httpCancellationToken = cancellationToken ?? GetDefaultCancellationToken(); return(await Client.SendAsync(request, httpCancellationToken).ConfigureAwait(false)); } }
private void WriteFile(StreamWriter writer, FileDescription file) { if (file.IsRemote) { WriteParam(writer, "file", file.FilePath); } else { if (file.Stream == null) { using (FileStream stream = new FileStream(file.FilePath, FileMode.Open, FileAccess.Read, FileShare.Read)) { WriteFile(writer, stream, file.FileName); } } else { WriteFile(writer, file.Stream, file.FileName); } } }
private void PrepareRequestContent(ref HttpWebRequest request, SortedDictionary <string, object> parameters, FileDescription file) { if (request == null) { return; } HandleUnsignedParameters(parameters); if (request.ContentType == Constants.CONTENT_TYPE_APPLICATION_JSON) { using (var streamWriter = new StreamWriter(request.GetRequestStream())) { streamWriter.Write(ParamsToJson(parameters)); } } else { PrepareMultipartFormDataContent(request, parameters, file); } }
/// <summary> /// Custom call to cloudinary API /// </summary> /// <param name="method">HTTP method of call</param> /// <param name="url">URL to call</param> /// <param name="parameters">Dictionary of call parameters (can be null)</param> /// <param name="file">File to upload (must be null for non-uploading actions)</param> /// <returns>HTTP response on call</returns> public HttpWebResponse Call(HttpMethod method, string url, SortedDictionary <string, object> parameters, FileDescription file) { #if DEBUG Console.WriteLine(String.Format("{0} REQUEST:", method)); Console.WriteLine(url); #endif HttpWebRequest request = HttpWebRequest.Create(url) as HttpWebRequest; request.Method = Enum.GetName(typeof(HttpMethod), method); if (method == HttpMethod.POST && parameters != null) { request.ContentType = "multipart/form-data; boundary=" + HTTP_BOUNDARY; FinalizeUploadParameters(parameters); using (Stream requestStream = request.GetRequestStream()) { using (StreamWriter writer = new StreamWriter(requestStream) { AutoFlush = true }) { foreach (var param in parameters) { if (param.Value != null) { if (param.Value is IEnumerable <string> ) { foreach (var item in (IEnumerable <string>)param.Value) { WriteParam(writer, param.Key + "[]", item); } } else { WriteParam(writer, param.Key, param.Value.ToString()); } } } if (file != null) { WriteFile(writer, file); } writer.Write("--{0}--", HTTP_BOUNDARY); } } } else { byte[] authBytes = Encoding.ASCII.GetBytes(String.Format("{0}:{1}", Account.ApiKey, Account.ApiSecret)); request.Headers.Add("Authorization", String.Format("Basic {0}", Convert.ToBase64String(authBytes))); } try { return(request.GetResponse() as HttpWebResponse); } catch (WebException ex) { return(ex.Response as HttpWebResponse); } }
public virtual T CallAndParse <T>(HttpMethod method, string url, SortedDictionary <string, object> parameters, FileDescription file, Dictionary <string, string> extraHeaders = null) where T : BaseResult, new() { throw new NotImplementedException(); }
public virtual object InternalCall(HttpMethod method, string url, SortedDictionary <string, object> parameters, FileDescription file, Dictionary <string, string> extraHeaders = null) { throw new Exception("Please call overriden method"); }
/// <summary> /// Custom call to cloudinary API /// </summary> /// <param name="method">HTTP method of call</param> /// <param name="url">URL to call</param> /// <param name="parameters">Dictionary of call parameters (can be null)</param> /// <param name="file">File to upload (must be null for non-uploading actions)</param> /// <returns>HTTP response on call</returns> public HttpWebResponse Call(HttpMethod method, string url, SortedDictionary <string, object> parameters, FileDescription file) { #if DEBUG Console.WriteLine(String.Format("{0} REQUEST:", method)); Console.WriteLine(url); #endif HttpWebRequest request = HttpWebRequest.Create(url) as HttpWebRequest; request.Method = Enum.GetName(typeof(HttpMethod), method); request.UserAgent = USER_AGENT; if (Timeout > 0) { request.Timeout = Timeout; } if (method == HttpMethod.POST && parameters != null) { request.AllowWriteStreamBuffering = false; request.AllowAutoRedirect = false; if (UseChunkedEncoding) { request.SendChunked = true; } request.ContentType = "multipart/form-data; boundary=" + HTTP_BOUNDARY; if (!parameters.ContainsKey("unsigned") || parameters["unsigned"].ToString() == "false") { FinalizeUploadParameters(parameters); } using (Stream requestStream = request.GetRequestStream()) { using (StreamWriter writer = new StreamWriter(requestStream)) { foreach (var param in parameters) { if (param.Value != null) { if (param.Value is IEnumerable <string> ) { foreach (var item in (IEnumerable <string>)param.Value) { WriteParam(writer, param.Key + "[]", item); } } else { WriteParam(writer, param.Key, param.Value.ToString()); } } } if (file != null) { WriteFile(writer, file); } writer.Write("--{0}--", HTTP_BOUNDARY); } } } else { byte[] authBytes = Encoding.ASCII.GetBytes(String.Format("{0}:{1}", Account.ApiKey, Account.ApiSecret)); request.Headers.Add("Authorization", String.Format("Basic {0}", Convert.ToBase64String(authBytes))); } try { return((HttpWebResponse)request.GetResponse()); } catch (WebException ex) { var response = ex.Response as HttpWebResponse; if (response == null) { throw; } else { return(response); } } }
public async Task <RawUploadResult> UploadAsync(string resourceType, IDictionary <string, object> parameters, FileDescription fileDescription) { var url = Api.ApiUrlV.Action("upload").ResourceType(resourceType).BuildUrl(); ResetInternalFileDescription(fileDescription, int.MaxValue); if (parameters == null) { parameters = new SortedDictionary <string, object>(); } if (!(parameters is SortedDictionary <string, object>)) { parameters = new SortedDictionary <string, object>(parameters); } using (var response = await Api.CallAsync(HttpMethod.Post, url, (SortedDictionary <string, object>)parameters, fileDescription, null)) { return(await RawUploadResult.Parse(response)); } }
private static Stream GetFileStream(FileDescription file) => file.Stream ?? File.OpenRead(file.FilePath);
private void PrepareRequestContent(HttpRequestMessage request, SortedDictionary <string, object> parameters, FileDescription file, Dictionary <string, string> extraHeaders = null) { HandleUnsignedParameters(parameters); HttpContent content = extraHeaders != null && extraHeaders.ContainsKey(Constants.HEADER_CONTENT_TYPE) && extraHeaders[Constants.HEADER_CONTENT_TYPE] == Constants.CONTENT_TYPE_APPLICATION_JSON ? new StringContent(ParamsToJson(parameters), Encoding.UTF8, Constants.CONTENT_TYPE_APPLICATION_JSON) : PrepareMultipartFormDataContent(parameters, file, extraHeaders); if (extraHeaders != null) { foreach (var header in extraHeaders) { content.Headers.TryAddWithoutValidation(header.Key, header.Value); } } request.Content = content; }
/// <summary> /// Custom call to cloudinary API /// </summary> /// <param name="method">HTTP method of call</param> /// <param name="url">URL to call</param> /// <param name="parameters">Dictionary of call parameters (can be null)</param> /// <param name="file">File to upload (must be null for non-uploading actions)</param> /// <param name="extraHeaders">Headers to add to the request</param> /// <returns>HTTP response on call</returns> public HttpWebResponse Call(HttpMethod method, string url, SortedDictionary <string, object> parameters, FileDescription file, Dictionary <string, string> extraHeaders = null) { HttpWebRequest request = RequestBuilder(url); HttpWebResponse response = null; if (Timeout > 0) { request.Timeout = Timeout; } PrepareRequestBody(request, method, parameters, file, extraHeaders); try { response = (HttpWebResponse)request.GetResponse(); } catch (WebException ex) { response = ex.Response as HttpWebResponse; if (response == null) { throw; } } return(response); }
public async Task <HttpResponseMessage> CallAsync(HttpMethod method, string url, SortedDictionary <string, object> parameters, FileDescription file, Dictionary <string, string> extraHeaders = null) { using (var stream = new MemoryStream()) { var bytes = Encoding.ASCII.GetBytes(string.Format("{0}:{1}", Account.ApiKey, Account.ApiSecret)); using (var client = new HttpClient() { DefaultRequestHeaders = { { "User-Agent", string.IsNullOrEmpty(UserPlatform) ? USER_AGENT : string.Format("{0} {1}", UserPlatform, USER_AGENT) }, { "Authorization", string.Format("Basic {0}", Convert.ToBase64String(bytes)) } } }) { if (this.Timeout > 0) { client.Timeout = TimeSpan.FromMilliseconds(this.Timeout); } var content = new StreamContent(stream) { }; if (extraHeaders != null) { foreach (var extraHeader in extraHeaders) { content.Headers.Add(extraHeader.Key, extraHeader.Value); } } if (parameters != null && (method == HttpMethod.Post || method == HttpMethod.Put)) { content.Headers.Add("Content-Type", "multipart/form-data; boundary=notrandomsequencetouseasboundary"); if (!parameters.ContainsKey("unsigned") || parameters["unsigned"].ToString() == "false") { FinalizeUploadParameters(parameters); } var writer = new StreamWriter(stream); foreach (var parameter in parameters) { if (parameter.Value != null) { if (parameter.Value is IEnumerable <string> ) { foreach (var str in (IEnumerable <string>)parameter.Value) { WriteParam(writer, parameter.Key + "[]", str); } } else { WriteParam(writer, parameter.Key, parameter.Value.ToString()); } } } if (file != null) { WriteFile(writer, file); } writer.Write("--{0}--", HTTP_BOUNDARY); writer.Flush(); stream.Position = 0; } return(await client.SendAsync(new HttpRequestMessage(method, url) { Content = content })); } } }
private static void ResetInternalFileDescription(FileDescription file, int bufferSize = Int32.MaxValue) { file.BufferLength = bufferSize; file.EOF = false; file.BytesSent = 0; }
private void PrepareMultipartFormDataContent(HttpWebRequest request, SortedDictionary <string, object> parameters, FileDescription file) { request.ContentType = "multipart/form-data; boundary=" + HTTP_BOUNDARY; using (Stream requestStream = request.GetRequestStream()) { using (StreamWriter writer = new StreamWriter(requestStream)) { foreach (var param in parameters) { if (param.Value != null) { if (param.Value is IEnumerable <string> ) { foreach (var item in (IEnumerable <string>)param.Value) { WriteParam(writer, param.Key + "[]", item); } } else { WriteParam(writer, param.Key, param.Value.ToString()); } } } if (file != null) { WriteFile(writer, file); } writer.Write("--{0}--", HTTP_BOUNDARY); } } }
internal HttpWebRequest PrepareRequestBody(HttpWebRequest request, HttpMethod method, SortedDictionary <string, object> parameters, FileDescription file, Dictionary <string, string> extraHeaders = null) { SetHttpMethod(method, request); // Add platform information to the USER_AGENT header // This is intended for platform information and not individual applications! request.UserAgent = string.IsNullOrEmpty(UserPlatform) ? USER_AGENT : string.Format("{0} {1}", UserPlatform, USER_AGENT); byte[] authBytes = Encoding.ASCII.GetBytes(String.Format("{0}:{1}", Account.ApiKey, Account.ApiSecret)); request.Headers.Add("Authorization", String.Format("Basic {0}", Convert.ToBase64String(authBytes))); if (extraHeaders != null) { if (extraHeaders.ContainsKey("Content-Type")) { request.ContentType = extraHeaders["Content-Type"]; extraHeaders.Remove("Content-Type"); } foreach (var header in extraHeaders) { request.Headers[header.Key] = header.Value; } } if ((method == HttpMethod.POST || method == HttpMethod.PUT) && parameters != null) { request.AllowWriteStreamBuffering = false; request.AllowAutoRedirect = false; if (UseChunkedEncoding) { request.SendChunked = true; } PrepareRequestContent(ref request, parameters, file); } return(request); }
/// <summary> /// Custom call to cloudinary API /// </summary> /// <param name="method">HTTP method of call</param> /// <param name="url">URL to call</param> /// <param name="parameters">Dictionary of call parameters (can be null)</param> /// <param name="file">File to upload (must be null for non-uploading actions)</param> /// <param name="extraHeaders">Headers to add to the request</param> /// <returns>HTTP response on call</returns> public HttpResponseMessage Call(HttpMethod method, string url, SortedDictionary <string, object> parameters, FileDescription file, Dictionary <string, string> extraHeaders = null) { var request = RequestBuilder(url); HttpResponseMessage response = null; using (request) { PrepareRequestBody(request, method, parameters, file, extraHeaders); System.Threading.Tasks.Task <HttpResponseMessage> task2; if (Timeout > 0) { var cancellationTokenSource = new CancellationTokenSource(Timeout); task2 = client.SendAsync(request, cancellationTokenSource.Token); } else { task2 = client.SendAsync(request); } task2.Wait(); if (task2.IsFaulted) { throw task2.Exception; } response = task2.Result; if (task2.IsCanceled) { } if (task2.IsFaulted) { throw task2.Exception; } return(response); } }
private HttpContent PrepareMultipartFormDataContent(SortedDictionary <string, object> parameters, FileDescription file, Dictionary <string, string> extraHeaders = null) { var content = new MultipartFormDataContent(HTTP_BOUNDARY); foreach (var param in parameters) { if (param.Value != null) { if (param.Value is IEnumerable <string> ) { foreach (var item in (IEnumerable <string>)param.Value) { content.Add(new StringContent(item), String.Format("\"{0}\"", string.Concat(param.Key, "[]"))); } } else { content.Add(new StringContent(param.Value.ToString()), String.Format("\"{0}\"", param.Key)); } } } if (file != null) { if (file.IsRemote) { StringContent strContent = new StringContent(file.FilePath); strContent.Headers.Add("Content-Disposition", string.Format("form-data; name=\"{0}\"", "file")); content.Add(strContent); } else { Stream stream; if (file.Stream != null) { stream = file.Stream; } else { stream = File.OpenRead(file.FilePath); } if (extraHeaders != null && extraHeaders.ContainsKey("Content-Range")) { // Unfortunately we don't have ByteRangeStreamContent here, // let's create another stream from the original one stream = GetRangeFromFile(file, stream); } var streamContent = new StreamContent(stream); streamContent.Headers.Add("Content-Type", "application/octet-stream"); streamContent.Headers.Add("Content-Disposition", "form-data; name=\"file\"; filename=\"" + file.FileName + "\""); content.Add(streamContent, "file", file.FileName); } } return(content); }
private static void ResetInternalFileDescription(FileDescription file, int bufferSize = 2147483647) { file.BufferLength = bufferSize; file.EOF = false; file.BytesSent = 0; }
public static RawUploadResult Upload(this Cloudinary cloudinary, string resourceType, IDictionary <string, object> parameters, FileDescription fileDescription) { return(cloudinary.UploadAsync(resourceType, parameters, fileDescription).ExecSync()); }
/// <summary> /// Uploads a file to cloudinary. /// </summary> /// <param name="resourceType">Resource type ("image", "raw", "video", "auto")</param> /// <param name="parameters">Upload parameters.</param> /// <param name="fileDescription">File description.</param> public RawUploadResult Upload(string resourceType, IDictionary <string, object> parameters, FileDescription fileDescription) { string uri = m_api.ApiUrlV.Action("upload").ResourceType(resourceType).BuildUrl(); ResetInternalFileDescription(fileDescription); if (parameters == null) { parameters = new SortedDictionary <string, object>(); } if (!(parameters is SortedDictionary <string, object>)) { parameters = new SortedDictionary <string, object>(parameters); } using (HttpWebResponse response = m_api.Call(HttpMethod.POST, uri, (SortedDictionary <string, object>)parameters, fileDescription)) { return(RawUploadResult.Parse(response)); } }
private void PrepareRequestContent(HttpRequestMessage request, SortedDictionary <string, object> parameters, FileDescription file, Dictionary <string, string> extraHeaders = null) { //HttpRequestMessage req = (HttpRequestMessage) request; var content = new MultipartFormDataContent(HTTP_BOUNDARY); if (extraHeaders != null) { foreach (var header in extraHeaders) { content.Headers.TryAddWithoutValidation(header.Key, header.Value); } } if (!parameters.ContainsKey("unsigned") || parameters["unsigned"].ToString() == "false") { FinalizeUploadParameters(parameters); } else { if (parameters.ContainsKey("removeUnsignedParam")) { parameters.Remove("unsigned"); parameters.Remove("removeUnsignedParam"); } } foreach (var param in parameters) { if (param.Value != null) { if (param.Value is IEnumerable <string> ) { foreach (var item in (IEnumerable <string>)param.Value) { content.Add(new StringContent(item), String.Format("\"{0}\"", string.Concat(param.Key, "[]"))); } } else { content.Add(new StringContent(param.Value.ToString()), String.Format("\"{0}\"", param.Key)); } } } if (file != null) { if (file.IsRemote && file.Stream == null) { StringContent strContent = new StringContent(file.FilePath); strContent.Headers.Add("Content-Disposition", string.Format("form-data; name=\"{0}\"", "file")); content.Add(strContent); } else { Stream stream; if (file.Stream != null) { stream = file.Stream; } else { stream = File.OpenRead(file.FilePath); } if (extraHeaders != null && extraHeaders.ContainsKey("Content-Range")) { // Unfortunately we don't have ByteRangeStreamContent here, // let's create another stream from the original one stream = GetRangeFromFile(file, stream); } string fileName = string.IsNullOrWhiteSpace(file.FilePath) ? file.FileName : Path.GetFileName(file.FilePath); var streamContent = new StreamContent(stream); streamContent.Headers.Add("Content-Type", "application/octet-stream"); streamContent.Headers.Add("Content-Disposition", "form-data; name=\"file\"; filename=\"" + fileName + "\""); content.Add(streamContent, "file", fileName); } } request.Content = content; }
/// <summary> /// Call api synchronous and return response of specified type. /// </summary> /// <param name="method">HTTP method.</param> /// <param name="url">Url for api call.</param> /// <param name="parameters">Parameters for api call.</param> /// <param name="file">File to upload (must be null for non-uploading actions).</param> /// <param name="extraHeaders">Extra headers.</param> /// <returns>Return response of specified type.</returns> /// <typeparam name="T">Type of the parsed response.</typeparam> internal virtual T CallApi <T>(HttpMethod method, string url, BaseParams parameters, FileDescription file, Dictionary <string, string> extraHeaders = null) where T : BaseResult, new() { parameters?.Check(); return(CallAndParse <T>( method, url, (method == HttpMethod.PUT || method == HttpMethod.POST) ? parameters?.ToParamsDictionary() : null, file, extraHeaders)); }
internal HttpRequestMessage PrepareRequestBody(HttpRequestMessage request, HttpMethod method, SortedDictionary <string, object> parameters, FileDescription file, Dictionary <string, string> extraHeaders = null) { SetHttpMethod(method, request); // Add platform information to the USER_AGENT header // This is intended for platform information and not individual applications! request.Headers.Add("User-Agent", string.IsNullOrEmpty(UserPlatform) ? USER_AGENT : string.Format("{0} {1}", UserPlatform, USER_AGENT)); byte[] authBytes = Encoding.ASCII.GetBytes(String.Format("{0}:{1}", Account.ApiKey, Account.ApiSecret)); request.Headers.Add("Authorization", String.Format("Basic {0}", Convert.ToBase64String(authBytes))); if (extraHeaders != null) { if (extraHeaders.ContainsKey("Accept")) { request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(extraHeaders["Accept"])); extraHeaders.Remove("Accept"); } foreach (var header in extraHeaders) { request.Headers.TryAddWithoutValidation(header.Key, header.Value); } } if ((method == HttpMethod.POST || method == HttpMethod.PUT) && parameters != null) { if (UseChunkedEncoding) { request.Headers.Add("Transfer-Encoding", "chunked"); } PrepareRequestContent(request, parameters, file, extraHeaders); } return(request); }