public Task<HttpResponseMessage> PostNotification (BlackberryNotification notification) { var c = new MultipartContent ("related", Configuration.Boundary); c.Headers.Remove("Content-Type"); c.Headers.TryAddWithoutValidation("Content-Type", "multipart/related; boundary=" + Configuration.Boundary + "; type=application/xml"); var xml = notification.ToPapXml (); c.Add (new StringContent (xml, Encoding.UTF8, "application/xml")); var bc = new ByteArrayContent(notification.Content.Content); bc.Headers.Add("Content-Type", notification.Content.ContentType); foreach (var header in notification.Content.Headers) bc.Headers.Add(header.Key, header.Value); c.Add(bc); return PostAsync (Configuration.SendUrl, c); }
static void Main(string[] args) { var client = new HttpClient(); var batchRequest = new HttpRequestMessage( HttpMethod.Post, "http://fsatnav:8080/api/batch" ); var batchContent = new MultipartContent("mixed"); batchRequest.Content = batchContent; batchContent.Add( new HttpMessageContent( new HttpRequestMessage( HttpMethod.Get, "http://localhost:8080/api/products" ) ) ); batchContent.Add( new HttpMessageContent( new HttpRequestMessage( HttpMethod.Put, "http://localhost:8080/api/products" ) { Content = new StringContent("{\"Name\":\"Product X\",\"StockQuantity\":300}", Encoding.UTF8, "application/json") } ) ); using (Stream stdout = Console.OpenStandardOutput()) { Console.WriteLine("<<< REQUEST >>>"); Console.WriteLine(); Console.WriteLine(batchRequest); Console.WriteLine(); batchContent.CopyToAsync(stdout).Wait(); Console.WriteLine(); var batchResponse = client.SendAsync(batchRequest).Result; Console.WriteLine("<<< RESPONSE >>>"); Console.WriteLine(); Console.WriteLine(batchResponse); Console.WriteLine(); batchResponse.Content.CopyToAsync(stdout).Wait(); Console.WriteLine(); Console.WriteLine(); } Console.ReadLine(); }
static void Main(string[] args) { var client = new HttpClient(); var batchRequest = new HttpRequestMessage( HttpMethod.Post, "http://localhost:52857/api/$batch" ); var batchContent = new MultipartContent("mixed"); batchRequest.Content = batchContent; batchContent.Add( new HttpMessageContent( new HttpRequestMessage( HttpMethod.Get, "http://localhost:52857/api/TestClassOne" ) ) ); batchContent.Add( new HttpMessageContent( new HttpRequestMessage( HttpMethod.Get, "http://localhost:52857/api/TestClassTwo" ) ) ); using (Stream stdout = Console.OpenStandardOutput()) { Console.WriteLine("<<< REQUEST >>>"); Console.WriteLine(); Console.WriteLine(batchRequest); Console.WriteLine(); batchContent.CopyToAsync(stdout).Wait(); Console.WriteLine(); var batchResponse = client.SendAsync(batchRequest).Result; Console.WriteLine("<<< RESPONSE >>>"); Console.WriteLine(); Console.WriteLine(batchResponse); Console.WriteLine(); batchResponse.Content.CopyToAsync(stdout).Wait(); Console.WriteLine(); Console.WriteLine(); } Console.ReadLine(); }
public void Add_2() { var m = new MultipartContent ("a", "X"); var other = new MultipartContent ("2", "2a"); m.Add (other); var other2 = new MultipartContent ("3", "3a"); other2.Headers.Add ("9", "9n"); m.Add (other2); Assert.AreEqual ("multipart/a", m.Headers.ContentType.MediaType, "#1"); Assert.AreEqual (148, m.Headers.ContentLength, "#2"); Assert.AreEqual ("--X\r\nContent-Type: multipart/2; boundary=\"2a\"\r\n\r\n--2a\r\n\r\n--2a--\r\n\r\n--X\r\nContent-Type: multipart/3; boundary=\"3a\"\r\n9: 9n\r\n\r\n--3a\r\n\r\n--3a--\r\n\r\n--X--\r\n", m.ReadAsStringAsync ().Result, "#3"); Assert.AreEqual (other, m.First (), "#4"); }
public void ReadFromStreamAsyncShouldReturnUploadImageDataTest() { ImageMultipartMediaFormatter target = new ImageMultipartMediaFormatter(); Type type = typeof(UploadImageData); Stream readStream = null; MultipartContent content = new MultipartContent("form-data"); byte[] content_bytes=new byte[] { 10, 11, 12 }; StreamContent content_part = new StreamContent(new MemoryStream(content_bytes)); content_part.Headers.Add("Content-Disposition", @"form-data; name=fieldName; filename=image.jpg"); content_part.Headers.Add("Content-Type", "image/jpeg"); content.Add(content_part); IFormatterLogger formatterLogger = null; var actual = target.ReadFromStreamAsync(type, readStream, content, formatterLogger); var actualResult = actual.Result; Assert.IsInstanceOfType(actualResult,typeof(UploadImageData)); Assert.AreEqual(3, (actualResult as UploadImageData).ImageBuffer.Length); for (int ind = 0; ind < 3; ind++) { Assert.AreEqual(content_bytes[ind], (actualResult as UploadImageData).ImageBuffer[ind]); } Assert.AreEqual("image.jpg", (actualResult as UploadImageData).FileName); Assert.AreEqual("image/jpeg", (actualResult as UploadImageData).ImageType); }
public async Task ExecuteAsync(string accessToken, string ebookId, int partCount, Func<Stream, Task> streamHandler) { var message = new HttpRequestMessage(HttpMethod.Post, new Uri("http://localhost:20394/api/batch")); var content = new MultipartContent("mixed"); message.Content = content; for (int i = 0; i < partCount; ++i) { content.Add(new HttpMessageContent( new HttpRequestMessage(HttpMethod.Get, new Uri(string.Format("http://localhost:20394/api/ebooks/ebook/{0}/part/{1}", ebookId, i))))); } using (var client = new HttpClient()) { client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken); var response = await client.SendAsync(message); var streamProvider = await response.Content.ReadAsMultipartAsync(); foreach (var partialContent in streamProvider.Contents) { var part = await partialContent.ReadAsHttpResponseMessageAsync(); var partStream = await part.Content.ReadAsStreamAsync(); await streamHandler(partStream); } } }
public void Add() { var m = new MultipartContent ("a", "b"); var other = new MultipartContent ("2", "44"); other.Headers.Expires = new DateTimeOffset (2020, 11, 30, 19, 55, 22, TimeSpan.Zero); m.Add (other); Assert.AreEqual ("multipart/a", m.Headers.ContentType.MediaType, "#1"); Assert.AreEqual (114, m.Headers.ContentLength, "#2"); Assert.AreEqual ("--b\r\nContent-Type: multipart/2; boundary=\"44\"\r\nExpires: Mon, 30 Nov 2020 19:55:22 GMT\r\n\r\n--44\r\n\r\n--44--\r\n\r\n--b--\r\n", m.ReadAsStringAsync ().Result, "#3"); Assert.AreEqual (other, m.First (), "#4"); }
public void BeginBatch() { _batchId = Guid.NewGuid().ToString(); _changesetId = Guid.NewGuid().ToString(); this.Request = CreateRequest(CreateRequestUrl(FluentCommand.BatchLiteral)); this.Request.Method = RestVerbs.POST; var batchContent = new MultipartContent("mixed", "batch_" + _batchId); this.Request.Content = batchContent; this.Request.ContentType = "application/http"; var changesetContent = new MultipartContent("mixed", "changeset_" + _changesetId); batchContent.Add(changesetContent); _content = changesetContent; }
public void PostConvertFile_ConvertToKml_ShouldReturnByteArray() { var multipartContent = new MultipartContent(); var streamContent = new StreamContent(new MemoryStream(new byte[1] { 1 })); streamContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data") { Name = "\"files\"", FileName = "\"SomeFile.twl\"" }; streamContent.Headers.ContentType = new MediaTypeHeaderValue("application/kml"); multipartContent.Add(streamContent); _controller.Request = new HttpRequestMessage(); _controller.Request.Content = multipartContent; _gpsBabelGateway.ConvertFileFromat(Arg.Any<byte[]>(), "naviguide", "kml").Returns(Task.FromResult(new byte[2] { 1, 1 })); var response = _controller.PostConvertFile("kml").Result as OkNegotiatedContentResult<byte[]>; Assert.AreEqual(2, response.Content.Length); }
private static HttpRequestMessage CreateBatchedRequest(Uri batchEndPoint, IEnumerable <HttpRequestMessage> requestsToBatch) { MultipartContent multipartContent = new MultipartContent("mixed", "batch_" + Guid.NewGuid().ToString()); foreach (var request in requestsToBatch) { var httpMessageContent = new HttpMessageContent(request); httpMessageContent.Headers.Remove("Content-Type"); httpMessageContent.Headers.Add("Content-Type", "application/http"); httpMessageContent.Headers.Add("Content-Transfer-Encoding", "binary"); multipartContent.Add(httpMessageContent); } return(new HttpRequestMessage(HttpMethod.Post, batchEndPoint) { Content = multipartContent }); }
private static HttpResponseMessage GetMultipartResponse(IEnumerable <IWadoRsResponse> wadoResponses, string mimeType) { HttpResponseMessage response = new HttpResponseMessage( ); MultipartContent multiContent = new MultipartContent("related", "DICOM DATA BOUNDARY"); multiContent.Headers.ContentType.Parameters.Add(new System.Net.Http.Headers.NameValueHeaderValue("type", "\"" + mimeType + "\"")); response.Content = multiContent; foreach (var wadoResponse in wadoResponses) { StreamContent sContent = new StreamContent(wadoResponse.Content); sContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(wadoResponse.MimeType); multiContent.Add(sContent); } return(response); }
/// <summary> /// 图片上传 /// </summary> /// <param name="url">上传地址</param> /// <param name="stream">数据流</param> private string HttpUpLoad(string url, Stream stream, int ServiceId, string FileName) { HttpClient c = new HttpClient(); var bytes = StreamToBytes(stream); var fileContent = new ByteArrayContent(bytes); fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("name") { FileName = FileName }; MultipartContent content = new MultipartContent(); content.Add(fileContent); var response = c.PostAsync(url, content); string responseBody = response.Result.Content.ReadAsStringAsync().Result; var apiResult = JsonConvert.DeserializeObject <BaseWebApiResponse <string> >(responseBody); return(apiResult.Result); }
private async Task <DicomWebResponse <DicomDataset> > PostAsync( IEnumerable <byte[]> postContent, string studyInstanceUid, CancellationToken cancellationToken) { MultipartContent multiContent = GetMultipartContent(MediaTypeApplicationDicom.MediaType); foreach (byte[] content in postContent) { var byteContent = new ByteArrayContent(content); byteContent.Headers.ContentType = MediaTypeApplicationDicom; multiContent.Add(byteContent); } return(await PostMultipartContentAsync( multiContent, string.Format(DicomWebConstants.BasStudyUriFormat, studyInstanceUid), cancellationToken)); }
internal static async Task <bool> DeleteCustomer(string customerId, string caseId) { Customer customer = new Customer(); customer.CustomerId = Convert.ToInt32(customerId); customer.CaseId = caseId; var json = JsonConvert.SerializeObject(customer); var strContent = new StringContent(json, Encoding.UTF8, "application/json"); var content = new MultipartContent(); content.Add(strContent); HttpResponseMessage response = await SendApiRequest("api/Upload/DeleteCustomer", content); if (response.IsSuccessStatusCode) { return(true); } return(false); }
public static async Task <Customer> GetCustomerWithCustomerId(string customerId) { // Customer customer = null; Customer customer = new Customer(); customer.CustomerId = Convert.ToInt32(customerId); var json = JsonConvert.SerializeObject(customer); var strcontent = new StringContent(json, Encoding.UTF8, "application/json"); var content = new MultipartContent(); content.Add(strcontent); HttpResponseMessage response = await SendApiRequest("api/Upload/GetCustomerWithCustomerId", content); if (response.IsSuccessStatusCode) { customer = await response.Content.ReadAsAsync <Customer>(); } return(customer); }
internal HttpContent CreateHttpContent() { if (Contents != null) { if (Contents.Count == 1) { return(Contents[0]); } else if (Contents.Count > 0) { var content = new MultipartContent(); foreach (var item in Contents) { content.Add(item); } return(content); } } return(null); }
public HttpContent Build(string boundary) { if (boundary == null) { throw new ArgumentNullException("boundary"); } if (string.IsNullOrWhiteSpace(boundary)) { throw new ArgumentException("The provided boundary value is invalid", "boundary"); } MultipartContent content = new MultipartContent("mixed", boundary); foreach (var request in Requests) { HttpMessageContent messageContent = new HttpMessageContent(request); messageContent.Headers.ContentType = MediaTypeHeaderValue.Parse("application/http"); messageContent.Headers.Add("Content-Transfer-Encoding", "binary"); content.Add(messageContent); } return content; }
public async Task <bool> CreatePost(string messageUserId, string post, UserAccountEntity userAccountEntity) { try { var user = userAccountEntity.GetUserEntity(); var authenticationManager = new AuthenticationManager(); const string boundary = "abcdefghijklmnopqrstuvwxyz"; var theAuthClient = new HttpClient(); var request = new HttpRequestMessage(HttpMethod.Post, string.Format("https://{0}-gmsg.np.community.playstation.net/groupMessaging/v1/messageGroups/{1}/messages", user.Region, messageUserId)); var form = new MultipartContent("mixed", boundary); if (userAccountEntity.GetAccessToken().Equals("refresh")) { await authenticationManager.RefreshAccessToken(userAccountEntity); } request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", userAccountEntity.GetAccessToken()); var messageJson = new SendMessage { message = new Message() { body = post, fakeMessageUid = 1384958573288, messageKind = 1 } }; var json = JsonConvert.SerializeObject(messageJson); var stringContent = new StringContent(json, Encoding.UTF8, "application/json"); stringContent.Headers.Add("Content-Description", "message"); form.Add(stringContent); request.Content = form; HttpResponseMessage response = await theAuthClient.SendAsync(request); return(response.IsSuccessStatusCode); } catch (Exception) { { return(false); } } }
public async Task Check_firstBoundryBatchRequest_has_CRLR() { // Act HttpRequestMessage request = new HttpRequestMessage( HttpMethod.Post, "/odata/$batch"); string batchName = $"batch_{Guid.NewGuid()}"; var batchContent = new MultipartContent("mixed", batchName); var requestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost:5000/odata/Products?$orderby=Name&$select=Id,Name&$skip=0&$top=20"); var messageContent = new HttpMessageContent(requestMessage); if (messageContent.Headers.Contains("Content-Type")) { messageContent.Headers.Remove("Content-Type"); } messageContent.Headers.Add("Content-Type", "application/http"); messageContent.Headers.Add("Content-Transfer-Encoding", "binary"); requestMessage.Headers.Add("Accept", "application/json"); batchContent.Add(messageContent); request.Content = batchContent; HttpResponseMessage response = await client.SendAsync(request); var responseString = response.Content.ReadAsStringAsync().Result; Debug.WriteLine(responseString); var test = responseString.Take(54).ToArray(); Console.WriteLine(test); Console.WriteLine("Lenght: " + test.Length); Console.WriteLine("last character: " + test[51]); Console.WriteLine("char52: " + (int)test[52]); Console.WriteLine("char53: " + (int)test[53]); Assert.IsTrue(response.IsSuccessStatusCode, $"Status code: " + response.StatusCode.ToString()); }
public MultipartContent GetFileUploadContent(params string[] paths) { var content = new MultipartContent(); foreach (var path in paths) { var fileName = Path.GetFileName(path); content.Add(new StreamContent(File.OpenRead(path)) { Headers = { ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileNameStar = fileName } } }); } return(content); }
private void AddBlobToMultipartContent(MultipartContent content, Blob blob) { if (blob.File == null) { throw new ArgumentNullException("blob.File", "input blob has no file"); } if (!blob.File.Exists) { throw new FileNotFoundException(blob.File.FullName); } HttpContent part = new StreamContent(blob.File.OpenRead()); part.Headers.ContentType = new MediaTypeHeaderValue(blob.MimeType); part.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileName = blob.Filename }; part.Headers.Add("Content-Transfer-Encoding", "binary"); part.Headers.Add("Content-ID", "input"); content.Add(part); }
internal async static Task <HttpContent> CreateOuterRequestContent(IEnumerable <IClientServiceRequest> requests) { var mixedContent = new MultipartContent("mixed"); foreach (var request in requests) { mixedContent.Add(await CreateIndividualRequest(request).ConfigureAwait(false)); } // Batch request currently doesn't support GZip. Uncomment when the issue will be resolved. // https://code.google.com/p/google-api-dotnet-client/issues/detail?id=409 /*if (service.GZipEnabled) * { * var content = HttpServiceExtenstions.CreateZipContent(await mixedContent.ReadAsStringAsync() * .ConfigureAwait(false)); * content.Headers.ContentType = mixedContent.Headers.ContentType; * return content; * }*/ return(mixedContent); }
public HttpContent Build(string boundary) { if (boundary == null) { throw new ArgumentNullException("boundary"); } if (string.IsNullOrWhiteSpace(boundary)) { throw new ArgumentException("The provided boundary value is invalid", "boundary"); } MultipartContent content = new MultipartContent("mixed", boundary); foreach (var request in Requests) { HttpMessageContent messageContent = new HttpMessageContent(request); messageContent.Headers.ContentType = MediaTypeHeaderValue.Parse("application/http"); messageContent.Headers.Add("Content-Transfer-Encoding", "binary"); content.Add(messageContent); } return(content); }
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { if (request.Content == null || !request.Content.IsMimeMultipartContent("batch")) { return(request.CreateErrorResponse(HttpStatusCode.UnsupportedMediaType, "The mediatype is expected to be \"multipart/batch\" for a batching request")); } MultipartContent outerContent = new MultipartContent("batch"); HttpResponseMessage outerResponse = request.CreateResponse(); outerResponse.Content = outerContent; MultipartMemoryStreamProvider multipart = await request.Content.ReadAsMultipartAsync(); /// Load requests from multipart content. Submit each of them /// to the in memory batch server sequentially. They are then /// processed asynchronously. /// The individual response are gathered and added to the /// multipart content for return response. foreach (var content in multipart.Contents) { HttpResponseMessage innerResponse = null; try { var innerRequest = await content.ReadAsHttpRequestMessageAsync(); innerResponse = await _entry.SendAsync(innerRequest, cancellationToken); } catch (Exception) { innerResponse = new HttpResponseMessage(HttpStatusCode.BadRequest); } outerContent.Add(new HttpMessageContent(innerResponse)); } return(outerResponse); }
public async void GivenAMultipartRequestWithEmptyContent_WhenStoring_TheServerShouldReturnConflict() { var request = new HttpRequestMessage(HttpMethod.Post, "studies"); request.Headers.Add(HeaderNames.Accept, DicomWebClient.MediaTypeApplicationDicomJson.MediaType); var multiContent = new MultipartContent("related"); multiContent.Headers.ContentType.Parameters.Add(new System.Net.Http.Headers.NameValueHeaderValue("type", $"\"{DicomWebClient.MediaTypeApplicationDicom.MediaType}\"")); var byteContent = new ByteArrayContent(Array.Empty <byte>()); byteContent.Headers.ContentType = DicomWebClient.MediaTypeApplicationDicom; multiContent.Add(byteContent); request.Content = multiContent; DicomWebException <DicomDataset> exception = await Assert.ThrowsAsync <DicomWebException <DicomDataset> >( () => _client.PostMultipartContentAsync(multiContent, "studies")); Assert.Equal(HttpStatusCode.Conflict, exception.StatusCode); }
public virtual Task<HttpResponseMessage> CreateResponseMessageAsync(IList<HttpResponseMessage> responses, HttpRequestMessage request) { if (responses == null) { throw Error.ArgumentNull("responses"); } if (request == null) { throw Error.ArgumentNull("request"); } MultipartContent batchContent = new MultipartContent(MultiPartContentSubtype); foreach (HttpResponseMessage batchResponse in responses) { batchContent.Add(new HttpMessageContent(batchResponse)); } HttpResponseMessage response = request.CreateResponse(); response.Content = batchContent; return Task.FromResult(response); }
/// <summary> /// Builds the multipart content for a batch request using multiple change sets. /// </summary> private MultipartContent BuildMixedMultipartContent(SLBatchRequest batchRequest, string boundary) { var multipartContent = new MultipartContent("mixed", boundary); var request = new HttpRequestMessage(batchRequest.HttpMethod, Url.Combine(ServiceLayerRoot.ToString(), batchRequest.Resource)); if (batchRequest.Data != null) { request.Content = new StringContent(JsonConvert.SerializeObject(batchRequest.Data, batchRequest.JsonSerializerSettings), batchRequest.Encoding, "application/json"); } if (batchRequest.ContentID.HasValue) { request.Content.Headers.Add("Content-ID", batchRequest.ContentID.ToString()); } var innerContent = new HttpMessageContent(request); innerContent.Headers.Add("content-transfer-encoding", "binary"); multipartContent.Add(innerContent); return(multipartContent); }
public static bool TestStorageServiceCreateFile() { bool done = false; using (HttpClient client = HttpClient.Create("localhost", 3333)) { HttpClientRequest request = new HttpClientRequest(); request.Method = "POST"; request.Path = "/storage/1/0"; MultipartContent content = new MultipartContent(); FileContent fileContent = new FileContent("../../data/document/text.txt"); Dictionary <string, string> disposition = new Dictionary <string, string>(); disposition["name"] = "file"; disposition["filename"] = "text.txt"; fileContent.Headers["content-disposition"] = ContentDisposition.Encode(disposition); content.Add(fileContent); request.Content = content; client.SendRequest(request); HttpClientResponse response = client.GetResponse(); done = (response.StatusCode == 200); } return(done); }
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { if (request.Content == null || !request.Content.IsMimeMultipartContent("batch")) { return request.CreateErrorResponse(HttpStatusCode.UnsupportedMediaType, "The mediatype is expected to be \"multipart/batch\" for a batching request"); } MultipartContent outerContent = new MultipartContent("batch"); HttpResponseMessage outerResponse = request.CreateResponse(); outerResponse.Content = outerContent; MultipartMemoryStreamProvider multipart = await request.Content.ReadAsMultipartAsync(); /// Load requests from multipart content. Submit each of them /// to the in memory batch server sequentially. They are then /// processed asynchronously. /// The individual response are gathered and added to the /// multipart content for return response. foreach (var content in multipart.Contents) { HttpResponseMessage innerResponse = null; try { var innerRequest = await content.ReadAsHttpRequestMessageAsync(); innerResponse = await _entry.SendAsync(innerRequest, cancellationToken); } catch (Exception) { innerResponse = new HttpResponseMessage(HttpStatusCode.BadRequest); } outerContent.Add(new HttpMessageContent(innerResponse)); } return outerResponse; }
private HttpRequestMessage SetUpRequest(params string[] parts) { var content = new MultipartContent("mixed", "xyz-boundary"); foreach (var part in parts) { var nestedContent = new StringContent(part); nestedContent.Headers.ContentType = new MediaTypeHeaderValue("application/http"); nestedContent.Headers.Add("Content-Transfer-Encoding", "binary"); content.Add(nestedContent); } var request = new HttpRequestMessage(HttpMethod.Post, "http://example.com/api/odata/$batch") { Content = content }; request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml+atom")); return request; }
public override HttpRequestMessage CreateRequest(JsonOperationContext ctx, ServerNode node, out string url) { var request = new HttpRequestMessage { Method = HttpMethod.Post, Content = new BlittableJsonContent(stream => { using (var writer = new BlittableJsonTextWriter(ctx, stream)) { writer.WriteStartObject(); writer.WriteArray("Commands", _commands); writer.WriteEndObject(); } }) }; if (_attachmentStreams != null && _attachmentStreams.Count > 0) { var multipartContent = new MultipartContent { request.Content }; foreach (var stream in _attachmentStreams) { PutAttachmentCommandHelper.PrepareStream(stream); var streamContent = new AttachmentStreamContent(stream, CancellationToken); streamContent.Headers.TryAddWithoutValidation("Command-Type", "AttachmentStream"); multipartContent.Add(streamContent); } request.Content = multipartContent; } var sb = new StringBuilder($"{node.Url}/databases/{node.Database}/bulk_docs"); AppendOptions(sb); url = sb.ToString(); return(request); }
internal static async Task <bool> DeleteFile(string id) { CustomerFile custFile = new CustomerFile(); custFile.Id = new Guid(id); //custFile.DocumentType = docType; //custFile.CaseId = caseId; var json = JsonConvert.SerializeObject(custFile); var strContent = new StringContent(json, Encoding.UTF8, "application/json"); var content = new MultipartContent(); content.Add(strContent); HttpResponseMessage response = await SendApiRequest("api/Upload/DeleteFile", content); if (response.IsSuccessStatusCode) { return(true); } return(false); }
private HttpRequestMessage SetUpRequest(params string[] parts) { var content = new MultipartContent("mixed", "xyz-boundary"); foreach (var part in parts) { var nestedContent = new StringContent(part); nestedContent.Headers.ContentType = new MediaTypeHeaderValue("application/http"); nestedContent.Headers.Add("Content-Transfer-Encoding", "binary"); content.Add(nestedContent); } var request = new HttpRequestMessage(HttpMethod.Post, "http://example.com/api/odata/$batch") { Content = content }; request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml+atom")); return(request); }
public async Task ReadAsStringAsync_OneSubContentWithHeaders_MatchesExpected(MultipartContentToStringMode mode, bool async) { var subContent = new ByteArrayContent(Encoding.UTF8.GetBytes("This is a ByteArrayContent")); subContent.Headers.Add("someHeaderName", "andSomeHeaderValue"); subContent.Headers.Add("someOtherHeaderName", new[] { "withNotOne", "ButTwoValues" }); subContent.Headers.Add("oneMoreHeader", new[] { "withNotOne", "AndNotTwo", "butThreeValues" }); var mc = new MultipartContent("someSubtype", "theBoundary"); mc.Add(subContent); Assert.Equal( "--theBoundary\r\n" + "someHeaderName: andSomeHeaderValue\r\n" + "someOtherHeaderName: withNotOne, ButTwoValues\r\n" + "oneMoreHeader: withNotOne, AndNotTwo, butThreeValues\r\n" + "\r\n" + "This is a ByteArrayContent\r\n" + "--theBoundary--\r\n", await MultipartContentToStringAsync(mc, mode, async)); }
public async void GivenAMultipartRequestWithTypeParameterAndFirstSectionWithoutContentType_WhenStoring_TheServerShouldReturnOK() { var request = new HttpRequestMessage(HttpMethod.Post, "studies"); request.Headers.Add(HeaderNames.Accept, DicomWebClient.MediaTypeApplicationDicomJson.MediaType); var multiContent = new MultipartContent("related"); multiContent.Headers.ContentType.Parameters.Add(new System.Net.Http.Headers.NameValueHeaderValue("type", $"\"{DicomWebClient.MediaTypeApplicationDicom.MediaType}\"")); string studyInstanceUID = TestUidGenerator.Generate(); try { DicomFile dicomFile = Samples.CreateRandomDicomFile(studyInstanceUID); await using (MemoryStream stream = _recyclableMemoryStreamManager.GetStream()) { await dicomFile.SaveAsync(stream); var byteContent = new ByteArrayContent(stream.ToArray()); multiContent.Add(byteContent); } request.Content = multiContent; DicomWebResponse <DicomDataset> response = await _client.PostMultipartContentAsync(multiContent, "studies"); Assert.Equal(HttpStatusCode.OK, response.StatusCode); ValidationHelpers.ValidateReferencedSopSequence( response.Value, ConvertToReferencedSopSequenceEntry(dicomFile.Dataset)); } finally { await _client.DeleteStudyAsync(studyInstanceUID); } }
/// <summary> /// Creates the batch response message. /// </summary> /// <param name="responses">The responses for the batch requests.</param> /// <param name="request">The original request containing all the batch requests.</param> /// <param name="cancellationToken">The token to monitor for cancellation requests.</param> /// <returns>The batch response message.</returns> public virtual Task <HttpResponseMessage> CreateResponseMessageAsync(IList <HttpResponseMessage> responses, HttpRequestMessage request, CancellationToken cancellationToken) { if (responses == null) { throw new ArgumentNullException(nameof(responses)); } if (request == null) { throw new ArgumentNullException(nameof(request)); } MultipartContent batchContent = new MultipartContent(MultiPartContentSubtype); foreach (HttpResponseMessage batchResponse in responses) { batchContent.Add(new HttpMessageContent(batchResponse)); } HttpResponseMessage response = request.CreateResponse(); response.Content = batchContent; return(Task.FromResult(response)); }
public virtual Task <HttpResponseMessage> CreateResponseMessageAsync(IList <HttpResponseMessage> responses, HttpRequestMessage request) { if (responses == null) { throw Error.ArgumentNull("responses"); } if (request == null) { throw Error.ArgumentNull("request"); } MultipartContent batchContent = new MultipartContent(MultiPartContentSubtype); foreach (HttpResponseMessage batchResponse in responses) { batchContent.Add(new HttpMessageContent(batchResponse)); } HttpResponseMessage response = request.CreateResponse(); response.Content = batchContent; return(Task.FromResult(response)); }
public async Task GetDisplaysBatchAsync() { //A batch API endpoint can be used to send multiple requests together. This cuts down on excess HTTP traffic. //This Get display batch request can be done as a normal GET request if a batch request is not required. //Create the multipart/mixed message content MultipartContent content = new MultipartContent("mixed", "batch_" + Guid.NewGuid()); foreach (Display display in displaysToUse) { //Create a message to get a display. //Create the different parts of the multipart content HttpMessageContent getDisplayContent = new HttpMessageContent(new HttpRequestMessage(HttpMethod.Get, $"{ApiServer}/API/api/displays/{display.SerialNumber}")); content.Add(getDisplayContent); } var responses = await SendBatchAndCheckReturnResponsesSuccessAsync(content); //Take the response list and read them into a display list List <GetDisplaysResponse> displays = new List <GetDisplaysResponse> { }; foreach (HttpResponseMessage individualResponse in responses) { GetDisplaysResponse displayDetails = await individualResponse.Content.ReadAsAsync <GetDisplaysResponse>(); displays.Add(displayDetails); } //Check the results Assert.AreEqual(displaysToUse.Count(), displays.Count()); for (int index = 0; index < displaysToUse.Count; index++) { Assert.AreEqual(displaysToUse[index].SerialNumber, displays[index].SerialNumber); } }
public async Task <ServiceLayerResponse> PostMany(string query, List <string> payload, bool noRoute = false, bool returnContent = false) { MultipartContent multipart = new MultipartContent("mixed"); StringBuilder messageBuilder = new StringBuilder(512); string messageTemplate = string.Empty; messageBuilder.AppendLine($"POST /{query}"); messageBuilder.AppendLine("Content-Type: application/json; charset=utf-8"); if (!returnContent) { messageBuilder.AppendLine("Prefer: return-no-content"); } messageBuilder.AppendLine(""); messageBuilder.AppendLine("{0}"); messageBuilder.AppendLine(""); messageTemplate = messageBuilder.ToString(); int index = 0; foreach (var s in payload) { index++; string message = string.Format(messageTemplate, s); StringContent json = new StringContent(message, Encoding.UTF8, "application/json"); json.Headers.ContentType = new MediaTypeHeaderValue("application/http"); json.Headers.Add("Content-Transfer-Encoding", "binary"); json.Headers.Add("Content-ID", index.ToString()); multipart.Add(json); } return(await Send(HttpMethod.Post, "$batch", multipart, noRoute)); }
public async Task TestFileUpload() { var http = new HttpClient(); byte[] data = File.ReadAllBytes(HttpContext.Current.Server.MapPath("~/images/sailbig.jpg")); var fileContent = new ByteArrayContent(data); fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileName = "sailbig.jpg", Name="file", }; var mp = new MultipartContent(); mp.Add(fileContent); var response = await http.PostAsync(BaseUrl + "samples/PostFileValues", mp); Assert.IsTrue(response.IsSuccessStatusCode); var result = await response.Content.ReadAsStringAsync(); Console.WriteLine(result); }
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext) { var boundry = Guid.NewGuid().ToString(); var multipartFormDataContent = new MultipartContent("mixed", boundry); //content. .StatusCode = (int)System.Net.HttpStatusCode.OK; var contentType = new MediaTypeHeaderValue("multipart/mixed"); // String.Format("multipart/mixed; boundary={0}", boundry)); var boundaryParameter = new NameValueHeaderValue("boundary", boundry); contentType.Parameters.Add(boundaryParameter); contentType.Parameters.Add(new System.Net.Http.Headers.NameValueHeaderValue("revision", "0.1")); content.Headers.ContentType = contentType; //content.Headers.Add("Accept", "multipart/mixed"); //content.Headers.Add("MIME-Version", "1.0"); var entities = (IEnumerable<object>)value; foreach (var entity in entities) { var entityContent = new ObjectContent<object>(entity, new JsonMediaTypeFormatter()); entityContent.Headers.LastModified = DateTime.UtcNow; // Add("Last-Modified", entity.LastModified.ToUniversalTime().ToString("R")); entityContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/x-" + entity.GetType().Name); multipartFormDataContent.Add(entityContent); } return multipartFormDataContent.CopyToAsync(writeStream); }
public static async Task <Response> PostFileAsync(string url, string file, Dictionary <string, string> formContent = null) { if (!File.Exists(file)) { return(await PostFormAsync(url, formContent)); } var content = new MultipartContent(); if (formContent != null && formContent.Count > 0) { foreach (var name in formContent.Keys) { content.Headers.Add(name, formContent[name]); } } using (var stream = File.OpenRead(file)) { content.Add(new StreamContent(stream)); return(await RequestAsync(url, HttpMethod.Post, content)); } }
public async Task TestFileUpload() { var http = new HttpClient(); byte[] data = File.ReadAllBytes(HttpContext.Current.Server.MapPath("~/images/sailbig.jpg")); var fileContent = new ByteArrayContent(data); fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileName = "sailbig.jpg", Name = "file", }; var mp = new MultipartContent(); mp.Add(fileContent); var response = await http.PostAsync(BaseUrl + "samples/PostFileValues", mp); Assert.IsTrue(response.IsSuccessStatusCode); var result = await response.Content.ReadAsStringAsync(); Console.WriteLine(result); }
public async Task UploadMultipartOriginal(string path, int bufferSize = DefaultBufferSize) { var record = new FileRecord(); using (var fileStream = File.OpenRead(path)) using (var bufferedStream = new ProgressStream(fileStream, Progress, bufferSize)) { using (var multipart = new MultipartContent()) using (var fileContent = new StreamContent(bufferedStream, bufferSize)) { multipart.Add(fileContent); var contentDispositionHeader = new ContentDispositionHeaderValue("attachment") { CreationDate = DateTime.Now, FileName = Path.GetFileName(path), Size = fileStream.Length }; fileContent.Headers.ContentDisposition = contentDispositionHeader; var response = await Client.PostAsync($"{Constants.FilesRoute}/{Constants.UploadMultipartOriginal}", multipart); } } }
public async Task Post() { var dir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase); var file = dir.Substring(6, dir.Length - 6) + @"\icon.png"; var bytes = File.ReadAllBytes(file); var fileContent = new ByteArrayContent(bytes); fileContent.Headers.ContentType = new MediaTypeHeaderValue("image/jpeg"); fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileName = "myFilename.jpg" }; var preProcessor = Substitute.For <IPreprocessor>(); preProcessor.Process(bytes, "image/jpeg", "myFilename.jpg"); var store = Substitute.For <IDataStore>(); var api = new ImageApi(preProcessor, store) { Request = new HttpRequestMessage(), }; var content = new MultipartContent(); content.Add(fileContent); api.Request.Content = content; var response = await api.Post(); Assert.IsNotNull(response); Assert.AreEqual(HttpStatusCode.Created, response.StatusCode); Assert.IsNotNull(response.Content); preProcessor.Received().Process(bytes, "image/jpeg", "myFilename.jpg"); }
public void ReadAsMultipartAsync_NestedMultipartContent(string boundary) { const int nesting = 10; const string innerText = "Content"; MultipartContent innerContent = new MultipartContent("mixed", boundary); innerContent.Add(new StringContent(innerText)); for (var cnt = 0; cnt < nesting; cnt++) { string outerBoundary = String.Format("{0}_{1}", boundary, cnt); MultipartContent outerContent = new MultipartContent("mixed", outerBoundary); outerContent.Add(innerContent); innerContent = outerContent; } MemoryStream memStream = new MemoryStream(); innerContent.CopyToAsync(memStream).Wait(); memStream.Position = 0; byte[] data = memStream.ToArray(); HttpContent content = new ByteArrayContent(data); content.Headers.ContentType = innerContent.Headers.ContentType; for (var cnt = 0; cnt < nesting + 1; cnt++) { MultipartMemoryStreamProvider result = content.ReadAsMultipartAsync().Result; Assert.Equal(1, result.Contents.Count); content = result.Contents[0]; Assert.NotNull(content); } string text = content.ReadAsStringAsync().Result; Assert.Equal(innerText, text); }
public void Add_Resursive () { var m = new MultipartContent ("1", "1a"); var other = new MultipartContent ("2", "2a"); m.Add (other); var other2 = new MultipartContent ("3", "3a"); other.Add (other2); Assert.AreEqual ("multipart/1", m.Headers.ContentType.MediaType, "#1"); Assert.AreEqual (136, m.Headers.ContentLength, "#2"); Assert.AreEqual ("--1a\r\nContent-Type: multipart/2; boundary=\"2a\"\r\n\r\n--2a\r\nContent-Type: multipart/3; boundary=\"3a\"\r\n\r\n--3a\r\n\r\n--3a--\r\n\r\n--2a--\r\n\r\n--1a--\r\n", m.ReadAsStringAsync ().Result, "#3"); Assert.AreEqual (other, m.First (), "#4"); }
public void Configure(IApplicationBuilder app) { app.Use(async (context, next) => { if (!IsMultipartContentType(context.Request.ContentType)) { await next(); return; } context.Response.ContentType = "text/html"; await context.Response.WriteAsync("<html><body>Multipart received<br>"); // Read the request body as multipart sections. This does not buffer the content of each section. If you want to buffer the data // then that needs to be added either to the request body before you start or to the individual segments afterward. var boundary = GetBoundary(context.Request.ContentType); var reader = new MultipartReader(boundary, context.Request.Body); var section = await reader.ReadNextSectionAsync(); while (section != null) { await context.Response.WriteAsync("- Header count: " + section.Headers.Count + "<br>"); foreach (var headerPair in section.Headers) { await context.Response.WriteAsync("-- " + headerPair.Key + ": " + string.Join(", ", headerPair.Value) + "<br>"); } // Consume the section body here. // Nested? if (IsMultipartContentType(section.ContentType)) { await context.Response.WriteAsync("-- Nested Multipart<br>"); var subBoundary = GetBoundary(section.ContentType); var subReader = new MultipartReader(subBoundary, section.Body); var subSection = await subReader.ReadNextSectionAsync(); while (subSection != null) { await context.Response.WriteAsync("--- Header count: " + subSection.Headers.Count + "<br>"); foreach (var headerPair in subSection.Headers) { await context.Response.WriteAsync("---- " + headerPair.Key + ": " + string.Join(", ", headerPair.Value) + "<br>"); } subSection = await subReader.ReadNextSectionAsync(); } } // Drains any remaining section body that has not been consumed and reads the headers for the next section. section = await reader.ReadNextSectionAsync(); } await context.Response.WriteAsync("</body></html>"); }); app.Use(async (context, next) => { if (context.Request.Path != new PathString("/SendMultipart")) { await next(); return; } // For the purposes of the sample we're going to issue a multipart request to ourselves and then tunnel the response to the user. var client = new HttpClient(); client.BaseAddress = new Uri("http://localhost:" + context.GetFeature<IHttpConnectionFeature>().LocalPort); var content = new MultipartContent("stuff"); content.Add(new StringContent("Hello World")); content.Add(new FormUrlEncodedContent(new Dictionary<string, string>())); content.Add(new MultipartContent("nested") { new StringContent("Nested Hello World") }); var response = await client.PostAsync("", content); context.Response.StatusCode = (int)response.StatusCode; context.Response.ContentType = response.Content.Headers.ContentType.ToString(); await response.Content.CopyToAsync(context.Response.Body); }); app.Run(async context => { context.Response.ContentType = "text/html"; await context.Response.WriteAsync("<html><body>Normal request.<br>"); await context.Response.WriteAsync("<a href=\"/SendMultipart\">Send Multipart Request</a><br>"); await context.Response.WriteAsync("</body></html>"); }); }
public async Task<ActionResult> Create(EventInformation model) { var profile = _profileService.GetProfile(User.Identity.GetUserId().ToLong()); if (!ModelState.IsValid) { ModelState.AddModelError("", "All of the form fields are required"); var createModel = new CreateEventViewModel(profile); return View(createModel); } var start = new DateTime(model.StartDate.Year, model.StartDate.Month, model.StartDate.Day, model.StartTime.Hour, model.StartTime.Minute, model.StartTime.Second); var end = new DateTime(model.EndDate.Year, model.EndDate.Month, model.EndDate.Day, model.EndTime.Hour, model.EndTime.Minute, model.EndTime.Second); var ev = new Event { DateCreated = DateTime.UtcNow, StartTime = start, EndTime = end, Name = model.EventName, Description = model.Description, Privacy = model.PrivacyLevel, Owner = profile.User, Location = new Location { Name = model.LocationInput, Address = new Address { AddressLine1 = string.Format("{0} {1}", model.street_number, model.route), City = model.locality, CountryRegion = model.country, PostalCode = model.postal_code, StateProvince = model.state } } }; if (!model.lng.IsEmpty() && !model.lat.IsEmpty()) { ev.Location.Geography = DbGeography.FromText(string.Format("POINT ({0} {1})", model.lng, model.lat)); } if (model.Picture != null) { using (var content = new MultipartContent()) { content.Add(new StreamContent(model.Picture.InputStream)); var upload = new MediaUpload { Content = content, ContentSize = model.Picture.ContentLength, ContentType = model.Picture.ContentType }; var picture = await _mediaService.UploadMediaAsync(upload); ev.Picture = picture; Log.InfoFormat("Uploaded picture for event. MediaId={0}", picture.Id); } } // If they want to create on facebook, do it here try { if (model.CreateFacebookEvent) { var fbEvent = new FacebookEvent { Name = ev.Name, Description = ev.Description, State_Time = start, Owner = new FacebookIdentity { Id = profile.FacebookId } }; var eventId = await _facebookService.PublishEvent(profile.User, fbEvent); Log.InfoFormat("Created Facebook Event for new event. UserId={0} FacebookId={1}", profile.User.Id, eventId); ev.FacebookId = eventId; } } catch (Exception e) { Log.ErrorFormat("Failed to create Facebook Event for new event. UserId={0}", profile.User.Id); } // Add yourself to the invitees list ev.Invitations = new List<Invitation> { new Invitation { FacebookUserId = profile.FacebookId, FacebookName = profile.GetFullName(), Response = RSVP.YES } }; // Save event _eventService.CreateEvent(ev); Log.InfoFormat("Created new Event. UserId={0} EventId={1}", profile.User.Id, ev.Id); return RedirectToAction("Event", new {Id = ev.Id}); }
public async Task<ActionResult> UploadMedia(HttpPostedFileBase file, long eventId) { if (file == null) return new HttpStatusCodeResult(HttpStatusCode.BadRequest, "You must provide a file"); var validExtensions = new[] {".jpg", ".jpeg", ".png", ".gif", ".mp4"}; var isValid = validExtensions.Any(ext => file.FileName.EndsWith(ext, true, CultureInfo.InvariantCulture)); if (!isValid) return new HttpStatusCodeResult(HttpStatusCode.BadRequest, "You must provide a file of type jpg, png, gif, or mp4"); var ev = _eventService.GetEvent(eventId); using (var content = new MultipartContent()) { content.Add(new StreamContent(file.InputStream)); var upload = new MediaUpload { Content = content, ContentSize = file.ContentLength, ContentType = file.ContentType }; var picture = await _mediaService.UploadMediaAsync(upload); _eventService.AddMediaToEvent(ev, picture); return Json(new { Url = picture.Url }); } }
internal MultipartContent PrepareMultipartContent(CancellationToken token) { var content = new MultipartContent("form-data", syncingBoundary); foreach (var item in needList) { token.ThrowIfCancellationRequested(); var @from = Convert.ToInt64(item.FileOffset); var length = Convert.ToInt64(item.BlockLength); var to = from + length - 1; switch (item.BlockType) { case RdcNeedType.Source: content.Add(new SourceFilePart(new NarrowedStream(sourceStream, from, to))); break; case RdcNeedType.Seed: content.Add(new SeedFilePart(@from, to)); break; default: throw new NotSupportedException(); } } return content; }
private async Task ExecuteAllOperationsAsync(OperationBatch batch) { long prevSeq = 0; if (this.context.BatchApiEndpoint == null) { MobileServiceTableOperation operation = await this.OperationQueue.PeekAsync(prevSeq, this.tableKind, this.tableNames); // keep taking out operations and executing them until queue is empty or operation finds the bookmark or batch is aborted while (operation != null) { using (await this.OperationQueue.LockItemAsync(operation.ItemId, this.CancellationToken)) { bool success = await this.ExecuteOperationAsync(operation, batch); if (batch.AbortReason.HasValue) { break; } if (success) { // we successfuly executed an operation so remove it from queue await this.OperationQueue.DeleteAsync(operation.Id, operation.Version); } // get next operation operation = await this.OperationQueue.PeekAsync(operation.Sequence, this.tableKind, this.tableNames); } } return; } var baseClient = this.client; // keep taking out operations and executing them until queue is empty or operation finds the bookmark or batch is aborted while (true) { var filter = new MultipartRequestHandler(); this.client = new MobileServiceClient(baseClient.MobileAppUri, filter); // Get X Operations off the queue List<MobileServiceTableOperation> items = new List<MobileServiceTableOperation>(); MobileServiceTableOperation operation = await this.OperationQueue.PeekAsync(prevSeq, this.tableKind, this.tableNames); while (operation != null && items.Count < context.BatchSize) { items.Add(operation); prevSeq = operation.Sequence; operation = await this.OperationQueue.PeekAsync(prevSeq, this.tableKind, this.tableNames); } if (items.Count == 0) { break; } filter.ExpectedRequests = items.Count; // TODO: LOCK OPERATIONS // TODO: Trigger pre send hooks... List<Task<bool>> runningOperations = new List<Task<bool>>(); MultipartContent finalContent = new MultipartContent("mixed", "batch_" + Guid.NewGuid().ToString()); foreach (var tableOperation in items) { Task<bool> tableOperationtask = this.ExecuteOperationAsync(tableOperation, batch); runningOperations.Add(tableOperationtask); } // TODO: Move the actual POST into the filter? // TODO: Adjust count if op task is cancelled/etc before hitting filter await filter.allOperationsQueued(); foreach (var content in filter.Parts) { finalContent.Add(content); } var batchedResponse = await baseClient.InvokeApiAsync(context.BatchApiEndpoint, finalContent, HttpMethod.Post, null, null, this.CancellationToken); MultipartMemoryStreamProvider responseContents = await batchedResponse.Content.ReadAsMultipartAsync(); // TODO: verify order on response == order on request for (int i = 0; i < responseContents.Contents.Count; i++) { var response = await responseContents.Contents[i].ReadAsHttpResponseMessageAsync(); var promise = filter.Promises[i]; promise.SetResult(response); } // Now review results of all operations in the batch for (int i = 0; i < runningOperations.Count; i++) { var tableOperationTask = runningOperations[i]; var success = await tableOperationTask; if (success) { // we successfuly executed an operation so remove it from queue var tableOperation = items[i]; await this.OperationQueue.DeleteAsync(tableOperation.Id, tableOperation.Version); } } if (batch.AbortReason.HasValue) { break; } } this.client = baseClient; }
public void ReadAsAsync_WhenContentIsMultipartContentAndFormatterCanReadFromTheContent() { MultipartContent mimeContent = new MultipartContent(); mimeContent.Add(new StringContent("multipartContent")); _formatterMock.Setup(f => f.CanWriteType(It.IsAny<Type>())).Returns(true); _formatterMock.Setup(f => f.CanReadType(It.IsAny<Type>())).Returns(true); _formatterMock.Setup(f => f.ReadFromStreamAsync(It.IsAny<Type>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<IFormatterLogger>())) .Returns<Type, Stream, HttpContent, IFormatterLogger>((type, stream, content, logger) => { MultipartMemoryStreamProvider provider = content.ReadAsMultipartAsync().Result; Assert.Equal(1, provider.Contents.Count); return TaskHelpers.FromResult<object>(provider.Contents[0].ReadAsStringAsync().Result); }); MediaTypeFormatter formatter = _formatterMock.Object; formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("multipart/mixed")); Assert.Equal("multipartContent", mimeContent.ReadAsAsync<string>(new[] { formatter }).Result); }
public async Task PushAsync_ExecutesThePendingOperations_InOrder_BatchedOne() { var hijack = new TestHttpHandler(); IMobileServiceClient service = new MobileServiceClient(MobileAppUriValidator.DummyMobileApp, hijack); var store = new MobileServiceLocalStoreMock(); await service.SyncContext.InitializeAsync(store, new MobileServiceSyncHandler()); IMobileServiceSyncTable table = service.GetSyncTable("someTable"); JObject item1 = new JObject() { { "id", "abc" } }, item2 = new JObject() { { "id", "def" } }; await table.InsertAsync(item1); await table.InsertAsync(item2); Assert.AreEqual(hijack.Requests.Count, 0); // create a new service to test that operations are loaded from store hijack = new TestHttpHandler(); var content = new MultipartContent("mixed", "6f078995-ef2a-4617-a4c9-5d8746b26d32"); var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("{\"id\":\"abc\",\"String\":\"Hey\"}", Encoding.UTF8, "application/json") }; content.Add(new HttpMessageContent(response)); hijack.AddResponseContent(content); content = new MultipartContent("mixed", "6f078995-ef2a-4617-a4c9-5d8746b26d32"); response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("{\"id\":\"def\",\"String\":\"What\"}", Encoding.UTF8, "application/json") }; content.Add(new HttpMessageContent(response)); hijack.AddResponseContent(content); service = new MobileServiceClient(MobileAppUriValidator.DummyMobileApp, hijack); await service.SyncContext.InitializeAsync(store, new MobileServiceSyncHandler()); service.SyncContext.BatchApiEndpoint = "batch"; service.SyncContext.BatchSize = 1; Assert.AreEqual(hijack.Requests.Count, 0); await service.SyncContext.PushAsync(); Assert.AreEqual(hijack.Requests.Count, 2); Assert.IsTrue(hijack.RequestContents[0].Contains(item1.ToString(Formatting.None))); Assert.IsTrue(hijack.RequestContents[0].Contains("X-ZUMO-FEATURES: TU,OL")); Assert.IsTrue(hijack.RequestContents[1].Contains(item2.ToString(Formatting.None))); Assert.IsTrue(hijack.RequestContents[1].Contains("X-ZUMO-FEATURES: TU,OL")); // create yet another service to make sure the old items were purged from queue hijack = new TestHttpHandler(); hijack.AddResponseContent("{\"id\":\"abc\",\"String\":\"Hey\"}"); service = new MobileServiceClient(MobileAppUriValidator.DummyMobileApp, hijack); await service.SyncContext.InitializeAsync(store, new MobileServiceSyncHandler()); Assert.AreEqual(hijack.Requests.Count, 0); await service.SyncContext.PushAsync(); Assert.AreEqual(hijack.Requests.Count, 0); }
public void ReadAsMultipartAsync_UsingMultipartContent(string boundary) { MultipartContent content = new MultipartContent("mixed", boundary); content.Add(new StringContent("A")); content.Add(new StringContent("B")); content.Add(new StringContent("C")); MemoryStream memStream = new MemoryStream(); content.CopyToAsync(memStream).Wait(); memStream.Position = 0; byte[] data = memStream.ToArray(); var byteContent = new ByteArrayContent(data); byteContent.Headers.ContentType = content.Headers.ContentType; MultipartMemoryStreamProvider result = byteContent.ReadAsMultipartAsync().Result; Assert.Equal(3, result.Contents.Count); Assert.Equal("A", result.Contents[0].ReadAsStringAsync().Result); Assert.Equal("B", result.Contents[1].ReadAsStringAsync().Result); Assert.Equal("C", result.Contents[2].ReadAsStringAsync().Result); }
public async Task<bool> CreatePostWithMedia(string messageUserId, string post, String path, byte[] fileStream, UserAccountEntity userAccountEntity) { try { var user = userAccountEntity.GetUserEntity(); var url = string.Format(EndPoints.CreatePost, user.Region, messageUserId); const string boundary = "abcdefghijklmnopqrstuvwxyz"; var messageJson = new SendMessage { message = new Message() { body = post, fakeMessageUid = 1384958573288, messageKind = 1 } }; var json = JsonConvert.SerializeObject(messageJson); var stringContent = new StringContent(json, Encoding.UTF8, "application/json"); stringContent.Headers.Add("Content-Description", "message"); var form = new MultipartContent("mixed", boundary) { stringContent }; Stream stream = new MemoryStream(fileStream); var t = new StreamContent(stream); var s = Path.GetExtension(path); if (s != null && s.Equals(".png")) { t.Headers.ContentType = new MediaTypeHeaderValue("image/png"); } else { var extension = Path.GetExtension(path); if (extension != null && (extension.Equals(".jpg") || extension.Equals(".jpeg"))) { t.Headers.ContentType = new MediaTypeHeaderValue("image/jpeg"); } else { t.Headers.ContentType = new MediaTypeHeaderValue("image/gif"); } } t.Headers.ContentType = new MediaTypeHeaderValue("image/jpeg"); t.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment"); t.Headers.Add("Content-Description", "image-data-0"); t.Headers.Add("Content-Transfer-Encoding", "binary"); t.Headers.ContentLength = stream.Length; form.Add(t); var result = await _webManager.PostData(new Uri(url), form, null, userAccountEntity); return result.IsSuccess; } catch (Exception ex) { throw new Exception("Failed to send post (with media)", ex); } }
public void MimeMultipartParserTestMultipartContent(string boundary) { MultipartContent content = new MultipartContent("mixed", boundary); content.Add(new StringContent("A")); content.Add(new StringContent("B")); content.Add(new StringContent("C")); MemoryStream memStream = new MemoryStream(); content.CopyToAsync(memStream).Wait(); memStream.Position = 0; byte[] data = memStream.ToArray(); for (var readSize = 1; readSize <= data.Length; readSize++) { MimeMultipartParser parser = CreateMimeMultipartParser(boundary); int totalBytesConsumed; List<string> bodyParts; MimeMultipartParser.State state = ParseBufferInSteps(parser, data, readSize, out bodyParts, out totalBytesConsumed); Assert.Equal(MimeMultipartParser.State.BodyPartCompleted, state); Assert.Equal(data.Length, totalBytesConsumed); Assert.Equal(4, bodyParts.Count); Assert.Empty(bodyParts[0]); Assert.True(bodyParts[1].EndsWith("A")); Assert.True(bodyParts[2].EndsWith("B")); Assert.True(bodyParts[3].EndsWith("C")); } }
/// <summary> /// <see cref="HttpContent"/> implementation which provides a byte range view over a stream used to generate HTTP /// 206 (Partial Content) byte range responses. If none of the requested ranges overlap with the current extend /// of the selected resource represented by the <paramref name="content"/> parameter then an /// <see cref="InvalidByteRangeException"/> is thrown indicating the valid Content-Range of the content. /// </summary> /// <param name="content">The stream over which to generate a byte range view.</param> /// <param name="range">The range or ranges, typically obtained from the Range HTTP request header field.</param> /// <param name="mediaType">The media type of the content stream.</param> /// <param name="bufferSize">The buffer size used when copying the content stream.</param> public ByteRangeStreamContent(Stream content, RangeHeaderValue range, MediaTypeHeaderValue mediaType, int bufferSize) { try { // If we have more than one range then we use a multipart/byteranges content type as wrapper. // Otherwise we use a non-multipart response. if (range.Ranges.Count > 1) { // Create Multipart content and copy headers to this content MultipartContent rangeContent = new MultipartContent(ByteRangesContentSubtype); _byteRangeContent = rangeContent; foreach (RangeItemHeaderValue rangeValue in range.Ranges) { try { ByteRangeStream rangeStream = new ByteRangeStream(content, rangeValue); HttpContent rangeBodyPart = new StreamContent(rangeStream, bufferSize); rangeBodyPart.Headers.ContentType = mediaType; rangeBodyPart.Headers.ContentRange = rangeStream.ContentRange; rangeContent.Add(rangeBodyPart); } catch (ArgumentOutOfRangeException) { // We ignore range errors until we check that we have at least one valid range } } // If no overlapping ranges were found then stop if (!rangeContent.Any()) { ContentRangeHeaderValue actualContentRange = new ContentRangeHeaderValue(content.Length); string msg = "ByteRangeStreamNoneOverlap"; throw new InvalidByteRangeException(actualContentRange, msg); } } else if (range.Ranges.Count == 1) { try { ByteRangeStream rangeStream = new ByteRangeStream(content, range.Ranges.First()); _byteRangeContent = new StreamContent(rangeStream, bufferSize); _byteRangeContent.Headers.ContentType = mediaType; _byteRangeContent.Headers.ContentRange = rangeStream.ContentRange; } catch (ArgumentOutOfRangeException) { ContentRangeHeaderValue actualContentRange = new ContentRangeHeaderValue(content.Length); string msg = "ByteRangeStreamNoOverlap"; throw new InvalidByteRangeException(actualContentRange, msg); } } else { throw new ArgumentException("range"); } // Copy headers from byte range content so that we get the right content type etc. _byteRangeContent.Headers.CopyTo(Headers); _content = content; _start = content.Position; } catch { if (_byteRangeContent != null) { _byteRangeContent.Dispose(); } throw; } }
/// <summary> /// Create a batching request content. The content contains three body part requests. /// </summary> /// <param name="baseAddress"></param> /// <param name="batchContent"></param> private static void CreateBatchedRequest(string baseAddress, MultipartContent batchContent) { batchContent.Add( new HttpMessageContent( new HttpRequestMessage( HttpMethod.Get, baseAddress + "/api/demo" ) ) ); // this request is expected to recieve a 404 batchContent.Add( new HttpMessageContent( new HttpRequestMessage( HttpMethod.Get, baseAddress + "/not/found" ) ) ); batchContent.Add( new HttpMessageContent( new HttpRequestMessage( HttpMethod.Get, baseAddress + "/api/demo/1" ) ) ); }
public void Add_Invalid() { var m = new MultipartContent ("a", "b"); try { m.Add (null); Assert.Fail ("#1"); } catch (ArgumentNullException) { } }