public virtual async Task <IList <HttpRequestMessage> > ParseBatchRequestsAsync( HttpRequestMessage request, CancellationToken cancellationToken ) { if (request == null) { throw Error.ArgumentNull("request"); } List <HttpRequestMessage> requests = new List <HttpRequestMessage>(); cancellationToken.ThrowIfCancellationRequested(); MultipartStreamProvider streamProvider = await request.Content.ReadAsMultipartAsync(); foreach (HttpContent httpContent in streamProvider.Contents) { cancellationToken.ThrowIfCancellationRequested(); HttpRequestMessage innerRequest = request.RequestUri == null ? await httpContent.ReadAsHttpRequestMessageAsync() : await httpContent.ReadAsHttpRequestMessageAsync( request.RequestUri.Scheme ); innerRequest.CopyBatchRequestProperties(request); requests.Add(innerRequest); } return(requests); }
/// <summary> /// Initializes a new instance of the <see cref="MimeBodyPart"/> class. /// </summary> /// <param name="streamProvider">The stream provider.</param> /// <param name="maxBodyPartHeaderSize">The max length of the MIME header within each MIME body part.</param> /// <param name="parentContent">The part's parent content</param> public MimeBodyPart(MultipartStreamProvider streamProvider, int maxBodyPartHeaderSize, HttpContent parentContent) { Contract.Assert(streamProvider != null); Contract.Assert(parentContent != null); this._streamProvider = streamProvider; this._parentContent = parentContent; this.Segments = new List<ArraySegment<byte>>(2); this._headers = FormattingUtilities.CreateEmptyContentHeaders(); this.HeaderParser = new InternetMessageFormatHeaderParser(this._headers, maxBodyPartHeaderSize); }
public async Task<object> ToObjectAsync(MultipartStreamProvider provider, Type type) { var contents = provider.Contents; var textContents = contents.Where(p => string.IsNullOrWhiteSpace(p.Headers.ContentDisposition.FileName)); var fileContents = contents.Except(textContents); var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public); object obj = await ParseHttpContentToObjectAsync(type, textContents); await SetFilePropertiesAsync(fileContents, properties, obj); return obj; }
static async Task SaveAssembledDocuments(HttpResponseMessage response) { MultipartStreamProvider multipartStream = await response.Content.ReadAsMultipartAsync(); foreach (var attachment in multipartStream.Contents) { Stream writeAttachmentStream = await attachment.ReadAsStreamAsync(); using (FileStream output = new FileStream(@"C:\temp\" + attachment.Headers.ContentDisposition.FileName, FileMode.Create)) { writeAttachmentStream.CopyTo(output); } } }
public async Task BatchRequest_SubRequestPropertiesDoNotContainRoutingContext_CopyProperties() { // Arrange const string baseAddress = "http://localhost/api/"; HttpConfiguration config = new HttpConfiguration(); HttpServer server = new HttpServer(config); config.Routes.MapHttpBatchRoute( routeName: "Batch", routeTemplate: "api/$batch", batchHandler: new CustomHttpBatchHandler(server)); config.Routes.MapHttpRoute( "Default", "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional }); // Act using (HttpClient client = new HttpClient(server)) using (HttpRequestMessage batchRequest = new HttpRequestMessage(HttpMethod.Post, baseAddress + "$batch")) { batchRequest.Content = new MultipartContent("mixed") { new HttpMessageContent( new HttpRequestMessage(HttpMethod.Post, baseAddress + "values") { Content = new ObjectContent <string>("newValue", new JsonMediaTypeFormatter()) }), new HttpMessageContent(new HttpRequestMessage(HttpMethod.Get, baseAddress + "values/newValue")) }; using (HttpResponseMessage batchResponse = await client.SendAsync(batchRequest, CancellationToken.None)) { MultipartStreamProvider streamProvider = await batchResponse.Content.ReadAsMultipartAsync(); foreach (HttpContent content in streamProvider.Contents) { HttpResponseMessage response = await content.ReadAsHttpResponseMessageAsync(); string result = await response.Content.ReadAsStringAsync(); // Assert Assert.Equal("\"newValue\"", result); } } } }
public virtual async Task <IList <HttpRequestMessage> > ParseBatchRequestsAsync(HttpRequestMessage request) { if (request == null) { throw Error.ArgumentNull("request"); } List <HttpRequestMessage> requests = new List <HttpRequestMessage>(); MultipartStreamProvider streamProvider = await request.Content.ReadAsMultipartAsync(); foreach (HttpContent httpContent in streamProvider.Contents) { HttpRequestMessage innerRequest = await httpContent.ReadAsHttpRequestMessageAsync(); requests.Add(innerRequest); } return(requests); }
static Task <Stream> ProcessBody(MultipartStreamProvider multipart) { var first = multipart.Contents.FirstOrDefault(); if (first == null) { throw new("Expected the multipart response have at least one part which contains the GraphQL response data."); } var name = first.Headers.ContentDisposition?.Name; if (name == null) { throw new("Expected the first part in the multipart response to be named."); } return(first.ReadAsStreamAsync()); }
/// <summary> /// Initializes a new instance of the <see cref="MimeMultipartBodyPartParser"/> class. /// </summary> /// <param name="content">An existing <see cref="HttpContent"/> instance to use for the object's content.</param> /// <param name="streamProvider">A stream provider providing output streams for where to write body parts as they are parsed.</param> /// <param name="maxMessageSize">The max length of the entire MIME multipart message.</param> /// <param name="maxBodyPartHeaderSize">The max length of the MIME header within each MIME body part.</param> public MimeMultipartBodyPartParser( HttpContent content, MultipartStreamProvider streamProvider, long maxMessageSize, int maxBodyPartHeaderSize) { Contract.Assert(content != null, "content cannot be null."); Contract.Assert(streamProvider != null, "streamProvider cannot be null."); string boundary = ValidateArguments(content, maxMessageSize, true); _mimeParser = new MimeMultipartParser(boundary, maxMessageSize); _currentBodyPart = new MimeBodyPart(streamProvider, maxBodyPartHeaderSize, content); _content = content; _maxBodyPartHeaderSize = maxBodyPartHeaderSize; _streamProvider = streamProvider; }
public void Success() { //TODO: Batch not support now HttpClient client = new HttpClient(); HttpRequestMessage batchRequest = new HttpRequestMessage(HttpMethod.Post, string.Format(Common.Tpl, "$batch")); AddRequest(batchRequest, HttpMethod.Get, string.Format(Common.Tpl, "Tag")); AddRequest(batchRequest, HttpMethod.Get, string.Format(Common.Tpl, "AspNetUsers")); var batchResponse = client.SendAsync(batchRequest).Result; MultipartStreamProvider streamProvider = batchResponse.Content.ReadAsMultipartAsync().Result; foreach (var content in streamProvider.Contents) { HttpResponseMessage response = content.ReadAsHttpResponseMessageAsync().Result; if (response.IsSuccessStatusCode) { var b = response.Content.ToString(); } } }
private async Task <IDictionary <string, object> > ToModelDictionaryAsync( MultipartStreamProvider multipartProvider) { var dictionary = new Dictionary <string, object>(); // iterate all parts foreach (var part in multipartProvider.Contents) { // unescape the name var name = part.Headers.ContentDisposition.Name.Trim('"'); // if we have a filename, we treat the part as file upload, // otherwise as simple string, model binder will convert strings to other types. if (MultipartReducedMemoryStreamProvider.SuggestsFileContent(part.Headers)) { // set null if no content was submitted to have support for [Required] if (part.Headers.ContentLength.GetValueOrDefault() > 0) { dictionary[name] = new HttpPostedFileMultipart( part.Headers.ContentDisposition.FileName.Trim('"'), part.Headers.ContentType?.MediaType, await part.ReadAsStreamAsync() ); } else { dictionary[name] = null; } } else { dictionary[name] = await part.ReadAsStringAsync(); } } return(dictionary); }
public override async Task <object> ReadFromStreamAsync(Type type, Stream stream, HttpContent httpContent, IFormatterLogger iFormatterLogger) { MultipartStreamProvider parts = await httpContent.ReadAsMultipartAsync(); IEnumerable <HttpContent> contents = parts.Contents; HttpContent content = contents.FirstOrDefault(); foreach (HttpContent c in contents) { if (SupportedMediaTypes.Contains(c.Headers.ContentType)) { content = c; break; } } using (var msgStream = await content.ReadAsStreamAsync()) { DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(TenMsg)); TenMsg msg = (TenMsg)js.ReadObject(msgStream); Debug.WriteLine("msgString: " + msgStream.ToString()); int sender = msg.Sender; int receiver = msg.Receiver; byte phoneType = msg.PhoneType; bool isLocked = msg.IsLocked; DateTime msgTime = msg.MsgTime; string msgContent = msg.MsgContent; Debug.WriteLine("Msg Content: " + msg.MsgContent); return(new TenMsg(sender, receiver, phoneType, isLocked, msgTime, msgContent)); } }
/// <summary> /// Initializes a new instance of the <see cref="MimeMultipartBodyPartParser"/> class. /// </summary> /// <param name="content">An existing <see cref="HttpContent"/> instance to use for the object's content.</param> /// <param name="streamProvider">A stream provider providing output streams for where to write body parts as they are parsed.</param> public MimeMultipartBodyPartParser(HttpContent content, MultipartStreamProvider streamProvider) : this(content, streamProvider, DefaultMaxMessageSize, DefaultMaxBodyPartHeaderSize) { }