static async void upload_image(string path) { Console.WriteLine("Uploading {0}", path); try { using (var client = new HttpClient()) { using (var stream = File.OpenRead(path)) { var content = new MultipartFormDataContent(); var file_content = new ByteArrayContent(new StreamContent(stream).ReadAsByteArrayAsync().Result); file_content.Headers.ContentType = new MediaTypeHeaderValue("image/png"); file_content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileName = "screenshot.png", Name = "foo", }; content.Add(file_content); client.BaseAddress = new Uri("https://pajlada.se/poe/imgup/"); var response = await client.PostAsync("upload.php", content); response.EnsureSuccessStatusCode(); Console.WriteLine("Done"); } } } catch (Exception) { Console.WriteLine("Something went wrong while uploading the image"); } }
public string SendAddressesToApi(string csvPath) { using (var client = new HttpClient()) { client.BaseAddress = new Uri(CensusBatchGeoCodeUri); var content = new MultipartFormDataContent(); var fileContent = new ByteArrayContent(System.IO.File.ReadAllBytes("addresses.csv")); fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data") { Name = "addressFile", FileName = "addresses.csv" }; fileContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream"); content.Add(fileContent); // Not a FormUrlEncodedContent class due to an ostensible bug in census API that // rejects key/value formatting and requires 'benchmark' in a 'name' field var benchMarkContent = new StringContent("9"); benchMarkContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data") { Name = "benchmark" }; content.Add(benchMarkContent); var result = client.PostAsync("", content).Result; string resultContent = result.Content.ReadAsStringAsync().Result; return resultContent; } }
public void CreateBlob(Guid id, byte[] content, string fileName) { var bytes = new ByteArrayContent(content); bytes.Headers.ContentDisposition = new ContentDispositionHeaderValue("file") { FileName = fileName }; bytes.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream"); var request = new HttpRequestMessage(HttpMethod.Post, String.Format("/blobs/{0}", id)) { Content = bytes }; var response = _httpClient.SendAsync(request); try { var result = response.Result; var statusCode = result.StatusCode; if (statusCode == HttpStatusCode.Created) { return; } RaiseResponseError(request, result); } finally { Dispose(request, response); } }
public void ContentLength_UsePartialSourceArray_LengthMatchesArrayLength() { var contentData = new byte[10]; var content = new ByteArrayContent(contentData, 5, 3); Assert.Equal(3, content.Headers.ContentLength); }
public void ContentLength_UseWholeSourceArray_LengthMatchesArrayLength() { var contentData = new byte[10]; var content = new ByteArrayContent(contentData); Assert.Equal(contentData.Length, content.Headers.ContentLength); }
/// <summary> /// Create Multipart form-data HTTP Post to upload file to S3. /// </summary> /// <param name="s3Bucket">The Amazon S3 bucket name.</param> /// <param name="formData">The JSON object containing the pre-signed URL data.</param> /// <param name="mimeType">The MIME type of the file to be uploaded.</param> /// <param name="compressedFile">The gzipped file contents.</param> /// <returns>BlipResponse object with a status code and body text if applicable.</returns> private static BlipResponse PostFile(string s3Bucket, string formData, string mimeType, byte[] compressedFile) { HttpResponseMessage response; dynamic data = JsonConvert.DeserializeObject(formData); using (var client = new HttpClient()) { var url = $"https://s3.amazonaws.com/{s3Bucket}"; var requestContent = new MultipartFormDataContent(); var fileContent = new ByteArrayContent(compressedFile); fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse(mimeType); // Special parsing required due to a hyphen in the key string contentMd5 = JObject.Parse(data.ToString())["content-md5"]; requestContent.Add(new StringContent(data.acl.ToString()), "acl"); requestContent.Add(new StringContent(data.bucket.ToString()), "bucket"); requestContent.Add(new StringContent(data.key.ToString()), "key"); requestContent.Add(new StringContent(contentMd5), "content-md5"); requestContent.Add(new StringContent(data.policy.ToString()), "policy"); requestContent.Add(new StringContent(data.signature.ToString()), "signature"); requestContent.Add(new StringContent(data.AWSAccessKeyId.ToString()), "AWSAccessKeyId"); requestContent.Add(new StringContent(mimeType), "content-type"); requestContent.Add(fileContent, "file"); // The file must be added last response = client.PostAsync(url, requestContent).Result; } var statusCode = (int)response.StatusCode; // If the upload is not successful return the error message from S3 else return success response return statusCode != 204 ? new BlipResponse(statusCode, response.Content.ToString()) : new BlipResponse(statusCode, ""); }
protected override HttpRequestMessage BuildMessage(IRestRequest request) { // Create message content var content = new MultipartFormDataContent(); foreach (var param in request.Parameters) { var file = param.Value as FileParameter; if (file != null) { var contentPart = new ByteArrayContent(file.Content); contentPart.Headers.Add("Content-Type", file.ContentType); content.Add(contentPart, param.Key, file.Name); } else { var contentPart = new StringContent(param.Value.ToString()); content.Add(contentPart, param.Key); } } // Build message var message = new HttpRequestMessage(request.Verb.ToHttpMethod(), request.Command) { Content = content }; return message; }
public async Task<bool> UploadBytes(string url, byte[] data) { try { if (_networkInformation.QuickNetworkCheck()) { var native = new NativeMessageHandler(); var httpClient = new HttpClient(native); var message = new HttpRequestMessage(HttpMethod.Post, url); native.RegisterForProgress(message, (bytes, totalBytes, expected) => new TransferProgressMessage(url, bytes, totalBytes, expected, true).Send()); var content = new ByteArrayContent(data); message.Content = content; var result = await httpClient.SendAsync(message); return result.IsSuccessStatusCode; } } catch { Debug.WriteLine("WARNING: Could not upload: {0}", url); } return false; }
/// <summary> /// Assincronouslly send the fields in the list to webServer in url parameter /// NextStep: add a percentage of uploaded data! /// </summary> /// <param name="fields"></param> /// <param name="url"></param> /// <returns></returns> internal static async Task<string> send(List<field> fields, string url) { HttpClient httpClient = new HttpClient(); MultipartFormDataContent form = new MultipartFormDataContent(); foreach(field f in fields) { if(f.kind == fieldKind.text) { form.Add(new StringContent(f.content), f.name); } else if (f.kind == fieldKind.file) { HttpContent content = new ByteArrayContent(f.bytes); content.Headers.Add("Content-Type", f.contentType); form.Add(content, f.name, f.fileName); } } HttpResponseMessage response = await httpClient.PostAsync(url, form); response.EnsureSuccessStatusCode(); httpClient.Dispose(); return response.Content.ReadAsStringAsync().Result; }
private static void SendImageSet(ImageSet imageSet) { var multipartContent = new MultipartFormDataContent(); var imageSetJson = JsonConvert.SerializeObject(imageSet, new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver() }); multipartContent.Add(new StringContent(imageSetJson, Encoding.UTF8, "application/json"), "imageset"); int counter = 0; foreach (var image in imageSet.Images) { var imageContent = new ByteArrayContent(image.ImageData); imageContent.Headers.ContentType = new MediaTypeHeaderValue(image.MimeType); multipartContent.Add(imageContent, "image" + counter++, image.FileName); } var response = new HttpClient() .PostAsync("http://localhost:53908/api/send", multipartContent) .Result; var responseContent = response.Content.ReadAsStringAsync().Result; Trace.Write(responseContent); }
private static void Request_POST <T>(string url, string timeKey, T data) { System.Threading.Thread th = new System.Threading.Thread(new System.Threading.ThreadStart(async() => { using (System.Net.Http.HttpClient client = new System.Net.Http.HttpClient()) { //특정 'Accept' 헤더를 BSON으로 지정: 서버에서 BSON 형식으로 데이터를 반환하도록 요청 client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add( new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/bson")); //'Content-Type' 헤더 지정: 서버에서 게시할 데이터 형식 지정 //Post 데이터는 Bson 형식으로 표시됨 var bSonData = SerializeBson <T>(data); var byteArrayContent = new System.Net.Http.ByteArrayContent(bSonData); byteArrayContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/bson"); await client.PostAsync(url, byteArrayContent).ContinueWith(responseTask => { dicResult.Add(timeKey, responseTask.Result.ToString()); }); } })) { IsBackground = true }; th.Start(); }
public async Task<string> CreatePageForIncidentAsync(string siteRootDirectory, string sectionId, Incident incident, IEnumerable<FileContent> inspectionPhotos, IEnumerable<Video> incidentVideos) { var templateFile = Path.Combine(siteRootDirectory, @"Templates\IncidentOneNotePage.cshtml"); var template = System.IO.File.ReadAllText(templateFile); var viewBag = new RazorEngine.Templating.DynamicViewBag(); viewBag.AddValue("InspectionPhotos", inspectionPhotos); viewBag.AddValue("IncidentVideos", incidentVideos); var html = RazorEngine.Engine.Razor.RunCompile(template, "IncidentOneNotePage", typeof(Incident), incident, viewBag); var content = new MultipartFormDataContent(); content.Add(new StringContent(html, Encoding.UTF8, "text/html"), "Presentation"); foreach (var image in inspectionPhotos) { var itemContent = new ByteArrayContent(image.Bytes); var contentType = MimeMapping.GetMimeMapping(image.Name); itemContent.Headers.ContentType = new MediaTypeHeaderValue(contentType); content.Add(itemContent, image.Id); } this.pageEndPoint = string.Format("{0}/sections/{1}/pages", serviceBaseUrl, sectionId); var requestMessage = new HttpRequestMessage(HttpMethod.Post, pageEndPoint); requestMessage.Content = content; var responseMessage = await HttpSendAsync(requestMessage, accessToken); if (responseMessage.StatusCode != System.Net.HttpStatusCode.Created) throw new HttpResponseException(responseMessage.StatusCode); var reponseObject = await GetReponseObjectAsync(responseMessage); return (string)reponseObject.links.oneNoteWebUrl.href; }
public async Task<bool> UploadBytes(string url, byte[] data) { try { if (_networkInformation.QuickNetworkCheck()) { var h = new NativeMessageHandler(); var httpClient = new HttpClient(h); var message = new HttpRequestMessage(HttpMethod.Post, url); var content = new ByteArrayContent(data); message.Content = content; var result = await httpClient.SendAsync(message); return result.IsSuccessStatusCode; } } catch { Debug.WriteLine("WARNING: Could not upload: {0}", url); } return false; }
///// <summary> ///// ///// </summary> ///// <param name="actContext"></param> //public override void OnActionExecuted(HttpActionExecutedContext actContext) //{ // var content = actContext.Response.Content; // if (content != null) // { // string encoding = null; // CompressionType compressionType = GetCompressionType(actContext.Request, out encoding); // if (compressionType != CompressionType.None) // { // var bytes = content.ReadAsByteArrayAsync().Result; // if (bytes != null) // { // byte[] zlibbedContent = null; // zlibbedContent = CompressionHelper.CompressionByte(bytes, compressionType); // var newContent = new ByteArrayContent(zlibbedContent); // newContent.Headers.Add("Content-encoding", encoding); // newContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(content.Headers.ContentType.MediaType); // actContext.Response.Content = newContent; // } // } // } // base.OnActionExecuted(actContext); //} /// <summary> /// /// </summary> /// <param name="actionExecutedContext"></param> /// <param name="cancellationToken"></param> /// <returns></returns> public override async Task OnActionExecutedAsync(HttpActionExecutedContext actionExecutedContext, CancellationToken cancellationToken) { var content = actionExecutedContext.Response.Content; if (content != null) { string encoding = null; CompressionType compressionType = GetCompressionType(actionExecutedContext.Request, out encoding); if (compressionType != CompressionType.None) { var bytes = content.ReadAsByteArrayAsync().Result; if (bytes != null) { byte[] zlibbedContent = null; zlibbedContent = await CompressionHelper.CompressionByteAsync(bytes, compressionType); var newContent = new ByteArrayContent(zlibbedContent); newContent.Headers.Add("Content-encoding", encoding); newContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(content.Headers.ContentType.MediaType); actionExecutedContext.Response.Content = newContent; } } } await base.OnActionExecutedAsync(actionExecutedContext, cancellationToken); }
public async Task Handle200AndContentType() { // Arrange JToken root = null; var machine = new HttpResponseMachine(); machine.When(HttpStatusCode.OK, null, new MediaTypeHeaderValue("application/json")) .Then(async (l, r) => { var text = await r.Content.ReadAsStringAsync(); root = JToken.Parse(text); }); machine.When(HttpStatusCode.OK, null, new MediaTypeHeaderValue("application/xml")) .Then(async (l, r) => { }); var byteArrayContent = new ByteArrayContent(Encoding.UTF8.GetBytes("{\"hello\" : \"world\"}")); byteArrayContent.Headers.ContentType = new MediaTypeHeaderValue("application/json"); // Act await machine.HandleResponseAsync("", new HttpResponseMessage(HttpStatusCode.OK) { Content = byteArrayContent}); // Assert Assert.NotNull(root); }
public void Ctor() { byte[] b = { 4, 6 }; using (var m = new ByteArrayContent (b)) { } }
static void Main(string[] args) { string url = "http://*****:*****@"D:\GraduationMusic\ATsednya\Tsedenia GM - Atalay.mp3"; MemoryStream requestStream = new MemoryStream(); Stream fileStream = File.Open(path, FileMode.Open); var byteFile = ReadFully(fileStream); var base64Doc = Convert.ToBase64String(byteFile); HttpContent content = new ByteArrayContent(byteFile); using (var client = new HttpClient()) { client.BaseAddress = new Uri(url); client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); // New code: HttpResponseMessage response = client.PostAsync("api/trackdata/file", content).Result; var result = response.Content; } }
private async static Task<bool> SendMessageWithImageAsync(string message, string chatId, string messageId, Stream imageStream) { var tghttpClient = new HttpClient(); imageStream.Seek(0, SeekOrigin.Begin); var buf = ReadFully(imageStream); var imageContent = new ByteArrayContent(buf); imageContent.Headers.ContentType = MediaTypeHeaderValue.Parse("image/png"); // Send Message, as well as image var endpointUrl = new Uri(string.Format(RequestTemplate.RpcOpUrl, RequestTemplate.AppId, "sendPhoto")); var content = new MultipartFormDataContent(); /*content.Add(new FormUrlEncodedContent(new List<KeyValuePair<string,string>> { new KeyValuePair<string, string>("chat_id", chatId), new KeyValuePair<string, string>("reply_to_message_id", messageId), new KeyValuePair<string, string>("caption", message) }));*/ content.Add(imageContent, "photo", string.Format("{0}.png", Guid.NewGuid())); content.Add(new ByteArrayContent(Encoding.UTF8.GetBytes(chatId)),"chat_id"); content.Add(new ByteArrayContent(Encoding.UTF8.GetBytes(messageId)), "reply_to_message_id"); content.Add(new ByteArrayContent(Encoding.UTF8.GetBytes(message)), "aptiond"); var result = await tghttpClient.PostAsync(endpointUrl, content); var content2 = await result.Content.ReadAsStringAsync(); return result.IsSuccessStatusCode; }
public ElasticsearchResponse DoSyncRequest(string method, Uri uri, byte[] data = null) { var client = new System.Net.Http.HttpClient(); HttpResponseMessage response = null; byte[] result = null; HttpContent content = null; if (data != null) content = new ByteArrayContent(data); switch (method.ToLower()) { case "head": response = client.SendAsync(new HttpRequestMessage(HttpMethod.Head, uri) ).Result; result = response.Content.ReadAsByteArrayAsync().Result; break; case "delete": response = client.SendAsync(new HttpRequestMessage(HttpMethod.Delete, uri) { Content = content }).Result; result = response.Content.ReadAsByteArrayAsync().Result; break; case "put": response = client.PutAsync(uri, content).Result; result = response.Content.ReadAsByteArrayAsync().Result; break; case "post": response = client.PostAsync(uri, content).Result; result = response.Content.ReadAsByteArrayAsync().Result; break; case "get": response = client.GetAsync(uri).Result; result = response.Content.ReadAsByteArrayAsync().Result; break; } return ElasticsearchResponse.Create(this._settings, (int)response.StatusCode, method, uri.ToString(), data, result); }
public async Task<HttpResponseMessage> GetImage(string name) { var userEmails = await UsersForHub(); if (userEmails == null) { Services.Log.Error("No logged in user", null, "SetupToken"); return new HttpResponseMessage(HttpStatusCode.Unauthorized); } byte[] imageBytes = null; foreach (var email in userEmails) { if (imageBytes == null) { imageBytes = await GetStatusImageBytesForUser(email, name); } } if (imageBytes != null) { var content = new ByteArrayContent(imageBytes); content.Headers.ContentType = new MediaTypeHeaderValue("image/png"); return new HttpResponseMessage(HttpStatusCode.OK) { Content = content }; } else { Services.Log.Error(string.Format("Status image {0} not found", name)); return new HttpResponseMessage(HttpStatusCode.NotFound); } }
public void Should_Accept_Only_Text_Content() { // Arrange Mock<IStorageRepository> storageRepositoryMock; Mock<IFileProcessor> fileProcessorMock; Mock<IChecksumCalculator> checksumCalculatorMock; Mock<IMetadataRepository> metadataRepositoryMock; var controller = this.ConfigureController(out storageRepositoryMock, out fileProcessorMock, out checksumCalculatorMock, out metadataRepositoryMock); var multipartContent = new MultipartFormDataContent(); var binaryContent = Enumerable.Repeat(Enumerable.Range(14, 255).ToArray(), 20).SelectMany(x => x.Select(y => y)).Select(x=>(byte)x).ToArray(); var fileContent = new ByteArrayContent(binaryContent); fileContent.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("attachment") { FileName = "Test.txt" }; fileContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("something/that_we_dont_expect"); multipartContent.Add(fileContent); controller.Request.Content = multipartContent; // Act Task<IHttpActionResult> task = controller.Post(); task.Wait(); // Assert GenericValueResult<List<MetadataInfo>> result = task.Result as GenericValueResult<List<MetadataInfo>>; result.Should().NotBeNull("Wrong data type was returned from the controller"); var t = result.Value as IEnumerable<Models.MetadataInfo>; t.Should().NotBeNull("Wrong data type was returned as a result of controller's work"); var informationFromService = t.First(); informationFromService.Id.Should().NotHaveValue(); informationFromService.ProcessingResult.Should().Be(UploadController.ContentTypeCannotBeAcceptedMessage); }
private async Task ForwardToModBusProtocolAdapterAsync(byte[] message) { try { HttpContent content = new System.Net.Http.ByteArrayContent(message); content.Headers.ContentType = new MediaTypeHeaderValue(Constants.CONTENT_TYPE); content.Headers.ContentLength = message.Length; string requestUrl = IPHelper.GetAddress(); HttpResponseMessage response = await httpClient.PostAsync(requestUrl, content); Console.WriteLine("{0} - Forwarded msg to PA with status code '{1}'", DateTime.Now.ToString("hh:MM:ss.ffff"), response.StatusCode); } catch (WebException we) { Console.WriteLine("Web exception - {0}", we.Message); if (we.InnerException != null) { Console.WriteLine("Web inner exception - {0}", we.InnerException.Message); } } catch (Exception ex) { Console.WriteLine("Post exception - {0}", ex.Message); if (ex.InnerException != null) { Console.WriteLine("Post inner exception - {0}", ex.InnerException.Message); } } }
public async Task<string> SendRaw(string uri, byte[] json) { System.Net.Http.HttpClient http = new System.Net.Http.HttpClient(); var content = new ByteArrayContent(json); var response = await http.PostAsync(Host + uri, content); return await response.Content.ReadAsStringAsync(); }
public override HttpContent GetContent(HttpRequestParams parameters) { var resource = PrepareResource(); var content = new ByteArrayContent(resource); content.Headers.ContentType = new MediaTypeHeaderValue(contentType); return content; }
internal override HttpContent AsHttpContent() { var content = new MultipartFormDataContent(); var bytesContent = new ByteArrayContent(ContentBytes); bytesContent.Headers.ContentType = MediaTypeHeaderValue.Parse(ContentType); content.Add(bytesContent, Name, FileName); return content; }
public JsonHttpResponseMessage(HttpStatusCode responceStatusCode, Type responseDataType, object responseData) { StatusCode = responceStatusCode; dynamic convertedResponceData = Convert.ChangeType(responseData, responseDataType); var jss = new JavaScriptSerializer(); var encoder = new ASCIIEncoding(); Content = new ByteArrayContent(encoder.GetBytes(jss.Serialize(convertedResponceData))); Content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); }
public IObservable<HttpResponseMessage> GetResponse() { var addParam = new ParameterCollection(); var requestMessage = new HttpRequestMessage(_Method, _Endpoint); NetworkSettings.GetOptionRequestHeaders.Select(p => { requestMessage.Headers.Add(p.Key, p.Value); return p; }); if (_Method == HttpMethod.Get) { var requestUri = _Endpoint; var uriParameter = _ParameterCollection.ToUrlParameter(); if (uriParameter.Length > 0) { requestUri += "?" + uriParameter; } requestMessage.RequestUri = new Uri(requestUri); addParam = _ParameterCollection; } else if (_Method == HttpMethod.Post) { switch (_ContentType) { case ContentType.FormUrlEncoded: requestMessage.Content = new FormUrlEncodedContent(_ParameterCollection.Where(p => p.Value != null).Select(p => new KeyValuePair<string, string>(p.Name, p.Value.ToString()))); addParam = _ParameterCollection; break; case ContentType.MultipartFormData: requestMessage.Content = _ParameterCollection.Where(p => p.Value != null).Aggregate(new MultipartFormDataContent(), (c, p) => { if (p.FileName == null) { var sc = new StringContent(p.Value.ToString()); c.Add(sc, "\"" + p.Name + "\""); // TODO: ""を自分で付け加えないとname=statusとなってしまい無視されてしまう/あとでよく調べる必要あり } else { var bac = new ByteArrayContent((byte[])p.Value); c.Add(bac, p.Name, "\"" + p.FileName + "\""); } return c; }); break; } } var handler = new HttpClientHandler(); handler.UseProxy = NetworkSettings.Proxy != null; handler.Proxy = NetworkSettings.Proxy; var client = new HttpClient(new OAuthMessageHandler(_Consumer, _OAuthToken, _Realm, addParam, handler)); client.Timeout = NetworkSettings.Timeout; return client .SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead) .ToObservable(); }
/// <summary> /// Uploads an activity. /// </summary> /// <param name="file">The path to the activity file on your local hard disk.</param> /// <param name="dataFormat">The format of the file.</param> /// <param name="activityType">The type of the activity.</param> /// <returns>The status of the upload.</returns> public async Task<UploadStatus> UploadActivityAsync(StorageFile file, DataFormat dataFormat, ActivityType activityType = ActivityType.Ride) { String format = String.Empty; switch (dataFormat) { case DataFormat.Fit: format = "fit"; break; case DataFormat.FitGZipped: format = "fit.gz"; break; case DataFormat.Gpx: format = "gpx"; break; case DataFormat.GpxGZipped: format = "gpx.gz"; break; case DataFormat.Tcx: format = "tcx"; break; case DataFormat.TcxGZipped: format = "tcx.gz"; break; } HttpClient client = new HttpClient(); client.DefaultRequestHeaders.Add("Authorization", String.Format("Bearer {0}", Authentication.AccessToken)); MultipartFormDataContent content = new MultipartFormDataContent(); byte[] fileBytes = null; using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync()) { fileBytes = new byte[stream.Size]; using (DataReader reader = new DataReader(stream)) { await reader.LoadAsync((uint)stream.Size); reader.ReadBytes(fileBytes); } } var byteArrayContent = new ByteArrayContent(fileBytes); content.Add(byteArrayContent, "file", file.Name); HttpResponseMessage result = await client.PostAsync( String.Format("https://www.strava.com/api/v3/uploads?data_type={0}&activity_type={1}", format, activityType.ToString().ToLower()), content); String json = await result.Content.ReadAsStringAsync(); return Unmarshaller<UploadStatus>.Unmarshal(json); }
public async Task<HttpResponseMessage> PostAsync(string requestUrl, byte[] requestData) { var content = new ByteArrayContent(requestData); content.Headers.ContentLength = requestData.Length; using (var client = new HttpClient()) { return await client.PutAsync(requestUrl, content); } }
public static async Task<HttpContent> Clone(this HttpContent source) { if (source == null) return null; await source.LoadIntoBufferAsync(); var destination = new ByteArrayContent(await source.ReadAsByteArrayAsync()); CopyHeadersFrom(destination.Headers, source.Headers); return destination; }
public async Task<HttpResponseMessage> PostAsync(Uri uri, Dictionary<string, string> fields, string fileName, byte[] imageData) { ByteArrayContent file = new ByteArrayContent(imageData); MultipartFormDataContent form = new MultipartFormDataContent(); foreach (KeyValuePair<string, string> field in fields) form.Add(new StringContent(field.Value), "\"" + field.Key + "\""); form.Add(file, "\"upfile\"", "\"" + fileName + "\""); return await _client.PostAsync(EnforceHTTPS(uri), form); }
public async Task<string> Send(User U) { await U.SetBaseAddress(); ByteArrayContent C = new ByteArrayContent(Crypto.EncryptRequest(this)); C.Headers.Add("soapaction", "\"" + SoapAction + "\""); C.Headers.Add("content-type", "text/xml; charset=utf-8"); var Req = await U._client.PostAsync(String.Format("{0}Service.svc", this.Service), C); var ba = await Req.Content.ReadAsByteArrayAsync(); return Crypto.DecryptResponse(ba); }
/* Responsible for creating a request of the specified type. Used * only during POST and PUT since it requires a payload to be provided. */ async Task <Response <TOut> > CreateContentRequest <TOut>( string url, net.HttpMethod method, object input, Dictionary <string, string> headers) { using (var msg = CreateRequestMessage(method, url, headers)) { if (input is Stream stream) { using (var content = new net.StreamContent(stream)) { AddContentHeaders(content, headers); msg.Content = content; return(await GetResult <TOut>(msg)); } } else if (input is byte[] bytes) { using (var content = new net.ByteArrayContent(bytes)) { AddContentHeaders(content, headers); msg.Content = content; return(await GetResult <TOut>(msg)); } } var stringContent = input is string strInput ? strInput : JObject.FromObject(input).ToString(); using (var content = new net.StringContent(stringContent)) { AddContentHeaders(content, headers); msg.Content = content; return(await GetResult <TOut>(msg)); } } }
public BinaryContent(Http.ByteArrayContent content) : base(content) { }
public static async Task <string> HttpClientPostAsync2(string url, Dictionary <string, object> Headerdics, byte[] postdata, string datatype, CookieContainer cookieContainers, string redirecturl) { if (string.IsNullOrEmpty(url)) { return(""); } ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Ssl3 | SecurityProtocolType.Tls | SecurityProtocolType.Tls11; ServicePointManager.ServerCertificateValidationCallback = (object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) => { return(true); }; var res = ""; try { using (var handler = new HttpClientHandler()) { handler.CookieContainer = cookieContainers; using (var client = new HttpClient(handler)) { foreach (var pair in Headerdics) { client.DefaultRequestHeaders.TryAddWithoutValidation(pair.Key, (string)pair.Value); } System.Net.Http.ByteArrayContent content = new System.Net.Http.ByteArrayContent(postdata); using (HttpResponseMessage HttpResponse = await client.PostAsync(url, content)) { HttpResponse.EnsureSuccessStatusCode(); if (HttpResponse.Headers.Location != null) { redirecturl = HttpResponse.Headers.Location.ToString(); } if (HttpResponse.ToString().ToLower().Contains("gzip")) { using (Stream HttpResponseStream = await client.GetStreamAsync(url)) { using (var gzipStream = new GZipStream(HttpResponseStream, CompressionMode.Decompress)) { using (var streamReader = new StreamReader(gzipStream, Encoding.UTF8)) { res = streamReader.ReadToEnd(); } } } } else { using (HttpContent HttpContent = HttpResponse.Content) { res = await HttpContent.ReadAsStringAsync(); } } } } } } catch (WebException e) { using (WebResponse response = e.Response) { HttpWebResponse httpResponse = (HttpWebResponse)response; Console.WriteLine("Error code: {0}", httpResponse.StatusCode); using (Stream data = response.GetResponseStream()) { using (var reader = new StreamReader(data)) { res = reader.ReadToEnd(); } } } } catch (Exception ex) { if (ex.InnerException != null) { Debug.Print(ex.GetBaseException().Message.ToString()); } else { Debug.Print(ex.Message.ToString()); } } return(res); }
//Envoi de flux livraison à Mroad public static async Task <HttpResponseMessage> SendData(List <TournesValidesToAkanea> tournesValidesToAkanea, string intervention) { TimeSpan timeout = new TimeSpan(0, 0, 30); HttpResponseMessage response = null; using (HttpClient client = new HttpClient()) { client.BaseAddress = new Uri("https://1807-tms-messagerie.akanea.com/json/"); string accessId = "VIRTRP"; string userId = "VIRAPI"; string password = "******"; string token = null; Task <System.Net.Http.HttpResponseMessage> taskRetour = client.GetAsync($"Login/GetToken?accessId={accessId}&userId={userId}&password={password}"); taskRetour.Wait(); using (response = taskRetour.Result) { Task <string> task2 = response.Content.ReadAsStringAsync(); token = JsonConvert.DeserializeObject <string>(task2.Result); logger.Info($"Token gotten from Akanea : {token}"); response.EnsureSuccessStatusCode(); } try { // pour l'exemple // object bordereaux = null; List <TournesValidesToAkanea> bordereaux = tournesValidesToAkanea; var ss = JsonConvert.SerializeObject(bordereaux); logger.Info(string.Format("{0} => {1}", "json to Akanea", ss)); byte[] datas = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(bordereaux)); using (System.Net.Http.HttpContent byteContent = new System.Net.Http.ByteArrayContent(datas)) { byteContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json"); byteContent.Headers.ContentLength = datas.Length; logger.Info($"Envoi vers Akanea : {"https://1807-tms-messagerie.akanea.com/json/"}{intervention}?token={token}"); taskRetour = client.PostAsync($"{intervention}?token={token}", byteContent); taskRetour.Wait(); using (response = taskRetour.Result) { Task <string> task2 = response.Content.ReadAsStringAsync(); string message = task2.Result; logger.Info($"Retour message Akanea: {message}"); // response.EnsureSuccessStatusCode(); } } } finally { // libération jeton taskRetour = client.GetAsync($"Login/ReleaseToken?token={token}"); using (response = taskRetour.Result) { logger.Info($"Liberation de Token : {taskRetour.Result}"); // response.EnsureSuccessStatusCode(); } } } return(response); }
public async Task <string> HttpRequest ( IElevationServiceProvider serviceProvider, Stack <Coordinate> coordinates, string apikey, int maxCoordinatesPerRequest, Ticket ticket, bool logTraffic ) { //assertions: if (coordinates.Count == 0) { Debug.LogWarning("coordinates.Count is 0"); return(null); } // List <Coordinate> requestList = new List <Coordinate>(); //const int lengthLimit = 102375;//(bytes) this number is guesstimation, i found errors but no documentation on this int limit = maxCoordinatesPerRequest;//2200;//guesstimation for (int i = 0; i < limit && coordinates.Count != 0; i++) { requestList.Add(coordinates.Pop()); } //create the HttpContent for the form to be posted: System.Net.Http.ByteArrayContent requestContent = null; if (serviceProvider.httpMethod == HttpMethod.Post) { string json = serviceProvider.GetRequestContent(requestList); byte[] buffer = System.Text.Encoding.ASCII.GetBytes(json); requestContent = new ByteArrayContent(buffer); requestContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json"); //Debug.Log( "requestContent.Headers.ContentLength.Value: " + requestContent.Headers.ContentLength.Value ); //log request: if (logTraffic) { Debug.Log($"requesting { requestList.Count } values:\n{ json }"); } } //get the stream of the content. string result = null; while (result == null && ticket.valid) { try { HttpResponseMessage response; if (serviceProvider.httpMethod == HttpMethod.Post) { response = await _client.PostAsync( serviceProvider.RequestUri(null, apikey), requestContent ); } else if (serviceProvider.httpMethod == HttpMethod.Get) { response = await _client.GetAsync( serviceProvider.RequestUri(serviceProvider.GetRequestContent(requestList), apikey) ); } else { throw new System.NotImplementedException(); } result = await response.Content.ReadAsStringAsync(); if (result.StartsWith("<html>")) { const string ERROR_504 = "504 Gateway Time-out"; const string ERROR_502 = "502 Bad Gateway"; const string ERROR_500 = "500 Internal Server Error"; //log warning: if (result.Contains(ERROR_504)) { Debug.LogWarning(ERROR_504); } else if (result.Contains(ERROR_502)) { Debug.LogWarning(ERROR_502); } else if (result.Contains(ERROR_500)) { Debug.LogWarning(ERROR_500); } else { Debug.LogWarning($"invalid response:\n{ result }"); } //invalidate: result = null; await Task.Delay(1000); //try again after delay } else if (result.StartsWith("{\"error\": \"Invalid JSON.\"}")) { //log warning: Debug.LogWarning($"invalid JSON. Try decreasing { nameof(maxCoordinatesPerRequest) }"); await Task.Delay(1000); //try again after delay } } catch (System.Net.WebException ex) { Debug.LogException(ex); await Task.Delay(1000); //try again after delay } catch (System.Exception ex) { Debug.LogException(ex); await Task.Delay(1000); //try again after delay } } //log response: if (logTraffic) { Debug.Log($"\tresponse:\n{ result }"); } //return results: return(result); }
/// <summary> /// 上传多个二进制文件数组 /// </summary> /// <param name="url"></param> /// <param name="bytecontentlist">文件内容数组</param> /// <param name="filenamelist">文件名数组(与内容的序号相同)</param> /// <param name="RequestParam"></param> /// <param name="isGet"></param> /// <param name="havessl"></param> /// <param name="HeaderParam"></param> /// <param name="timeOutSecond"></param> /// <returns></returns> public HttpResponseMessage upAsycHttpFile(string url, List <byte[]> bytecontentlist, List <string> filenamelist, Dictionary <string, string> RequestParam = null, bool isGet = true, bool havessl = false, Dictionary <string, string> HeaderParam = null, int timeOutSecond = -1) { HttpClient client = null; if (bytecontentlist.Count != filenamelist.Count) { throw new Exception("DispErr_ContentAndFilenameNotEq"); } if (havessl) { client = new HttpClient(); } else { client = new HttpClient(); } if (timeOutSecond > 0) { client.Timeout = new TimeSpan(0, 0, timeOutSecond); } if (!string.IsNullOrEmpty(_tokenName)) { client.DefaultRequestHeaders.Add(_tokenName, _token); } if (HeaderParam != null) { foreach (var key in HeaderParam.Keys) { client.DefaultRequestHeaders.Add(key, HeaderParam[key]); } } // client.DefaultRequestHeaders.Add("Content-Type", "multipart/form-data"); MultipartFormDataContent form = new MultipartFormDataContent(); if (RequestParam != null && RequestParam.Keys.Count > 0) { foreach (var key in RequestParam.Keys) { //FrmLib.Log.commLoger.devLoger.InfoFormat("key:{0},vale:{1}", key, RequestParam[key]); var dataContent = new ByteArrayContent(Encoding.UTF8.GetBytes(RequestParam[key])); dataContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data") { Name = key }; form.Add(dataContent); } } for (int i = 0; i < bytecontentlist.Count; i++) { var fileContent = new System.Net.Http.ByteArrayContent(bytecontentlist[i]); fileContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream"); fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data") { Name = "file", FileName = "\"" + filenamelist[i] + "\"" }; form.Add(fileContent, "file" + i.ToString()); } try { //FrmLib.Log.commLoger.devLoger.InfoFormat("now PostAsync url: " + url); // var task1 = client.PostAsync(url, form); var task2 = client.PostAsync(url, form).Result; /* (requestTask) => * { * HttpResponseMessage response = requestTask.Result; * * return response; * * }); */ return(task2); } catch (Exception ex) { string errmessage = ex.Message; Exception tmpex = ex; while (tmpex.InnerException != null) { tmpex = tmpex.InnerException; errmessage = errmessage + System.Environment.NewLine + tmpex.Message; } FrmLib.Log.commLoger.runLoger.ErrorFormat("exception:" + errmessage); throw ex; } }