public IHttpActionResult Post([FromBody] ProfileUpdateVM profile) { #if OFF // http://stackoverflow.com/questions/10320232/how-to-accept-a-file-post-asp-net-mvc-4-webapi if (Request.Content.IsMimeMultipartContent()) { var provider = new MultipartMemoryStreamProvider(); Request.Content.ReadAsMultipartAsync(provider); foreach (HttpContent file in provider.Contents) { string filename = file.Headers.ContentDisposition.FileName.Trim('\"'); byte[] buffer = file.ReadAsByteArrayAsync().Result; string filePath = HttpContext.Current.Server.MapPath("~/" + filename); using (var sw = new StreamWriter(filePath)) { sw.Write(buffer); } } } #endif bool ret = _appUserRepo.UpdateProfile(profile); return Ok(ret); }
public async Task<IHttpActionResult> uploadPicture() { if (Request.Content.IsMimeMultipartContent()) { var streamProvider = new MultipartMemoryStreamProvider(); streamProvider = await Request.Content.ReadAsMultipartAsync(streamProvider); var item = streamProvider.Contents.Where(c => !string.IsNullOrEmpty(c.Headers.ContentDisposition.FileName)).First(); Stream stPicture = new MemoryStream(await item.ReadAsByteArrayAsync()); WeedCSharpClientProxy weedProxy = new WeedCSharpClientProxy(); var result = weedProxy.Upload(stPicture); var index = result.url.LastIndexOf('/') + 1; var fid = result.url.Substring(index); var tempUser = PostsLogic.postContext.AspNetUsers.First(u => u.Id == User.Identity.GetUserId()); // tempUser.ProfilePicture = fid; PostsLogic.postContext.SubmitChanges(); return Ok(fid); } return BadRequest(); }
public virtual async Task<IHttpActionResult> UploadFile() { if (!Request.Content.IsMimeMultipartContent()) throw new Exception(); var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); var fileInfo = new FileDataContract {UserName = User.Identity.Name}; Stream buffer = null; foreach (var content in provider.Contents) { var name = content.Headers.ContentDisposition.Name.Trim('\"'); if (string.Equals(name, "referenceNotes", StringComparison.InvariantCultureIgnoreCase)) { fileInfo.ReferenceNotes = await content.ReadAsStringAsync(); continue; } if (string.Equals(name, "fileHandler", StringComparison.InvariantCultureIgnoreCase)) { fileInfo.HandlerName = await content.ReadAsStringAsync(); continue; } if (string.Equals(name, "mediaType", StringComparison.InvariantCultureIgnoreCase)) { fileInfo.MediaType = await content.ReadAsStringAsync(); continue; } if (!string.Equals(name, "file", StringComparison.InvariantCultureIgnoreCase)) continue; fileInfo.OriginalFileName = content.Headers.ContentDisposition.FileName.Trim('\"'); buffer = await content.ReadAsStreamAsync(); } var result = await service.UpsertFileDataSource(fileInfo, buffer); return Ok(result); }
public virtual async Task<HttpResponseMessage> Post() { if (!Request.Content.IsMimeMultipartContent()) { return new HttpResponseMessage(HttpStatusCode.UnsupportedMediaType); } var provider = new MultipartMemoryStreamProvider(); await this.Request.Content.ReadAsMultipartAsync(provider); var ids = new List<string>(provider.Contents.Count); foreach (var file in provider.Contents) { var bytes = await file.ReadAsByteArrayAsync(); var id = await this.preprocessor.Process(bytes, file.Headers.ContentType.MediaType, file.Headers.ContentDisposition.FileName.Trim('\"')); ids.Add(id); } return new HttpResponseMessage(HttpStatusCode.Created) { Content = new StringContent(JsonConvert.SerializeObject(ids), Encoding.UTF8, "application/json"), }; }
public async Task<IHttpActionResult> Post() { var image = new UploadImage(); try { var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); foreach (var file in provider.Contents) { // Seems kind of hackish as a method for determining where the file name is in the content stream if (file.Headers.ContentDisposition.FileName != null) { // Get file specifics and save image.fileName = file.Headers.ContentDisposition.FileName.Trim('\"'); image.file = await file.ReadAsByteArrayAsync(); image = await this.processor.SaveAndResizeImage(image); } } } catch (Exception exception) { return InternalServerError(exception); } // Technically we could return the upload image json if we needed that client side return Ok(image.file); }
public void ReadAsMultipartAsync_ParsesEmptyContent(string boundary) { HttpContent content = CreateContent(boundary); MultipartMemoryStreamProvider result = content.ReadAsMultipartAsync().Result; Assert.Empty(result.Contents); }
public Task<HttpResponseMessage> Post() { if (Request.Content.IsMimeMultipartContent()) { var streamProvider = new MultipartMemoryStreamProvider(); var task = Request.Content .ReadAsMultipartAsync(streamProvider) .ContinueWith<HttpResponseMessage>(t => { if (t.IsFaulted || t.IsCanceled) { throw new HttpResponseException(HttpStatusCode.InternalServerError); } foreach (var item in streamProvider.Contents) { var getContentTask = item.ReadAsStreamAsync(); var csvReader = new CsvReader(new StreamReader(getContentTask.Result)); csvReader.Configuration.CultureInfo = CultureInfo.CurrentCulture; csvReader.Configuration.Delimiter = CultureInfo.CurrentCulture.TextInfo.ListSeparator; csvReader.Configuration.RegisterClassMap<ReadingMap>(); while (csvReader.Read()) { Debug.WriteLine(csvReader.GetRecord<Reading>()); } } return Request.CreateResponse(HttpStatusCode.OK, new { Result = "OK" }); }); return task; } else { throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted")); } }
public async Task<HttpResponseMessage> Upload() { var streamProvider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(streamProvider); var fileNames = new List<string>(); foreach (var item in streamProvider.Contents) { if (item.Headers.ContentDisposition.FileName != null) { var ms = item.ReadAsStreamAsync().Result; var fileLength = ms.Length; var info = new FileInfo(item.Headers.ContentDisposition.FileName.Replace("\"", "")); var allowFomat = new[] { ".png", ".jpg", ".jepg", ".gif" }; var isImage = allowFomat.Contains(info.Extension.ToLower()); var fileNewName = GetUniquelyString(); var localPath = HostingEnvironment.MapPath("~/upload/" + DateTime.Now.ToString("yyyyMMdd")) + "/" + fileNewName + info.Extension; if (isImage) { if (!Directory.Exists(Path.GetDirectoryName(localPath))) { Directory.CreateDirectory(Path.GetDirectoryName(localPath)); } byte[] fileBytes = new byte[fileLength]; ms.Read(fileBytes, 0, (int)fileLength); // File.Create(localPath + "/" + fileNewName + info.Extension); File.WriteAllBytes(localPath,fileBytes); ms.Close(); fileNames.Add(DateTime.Now.ToString("yyyyMMdd") +"/" + fileNewName + info.Extension); } } } return PageHelper.toJson(PageHelper.ReturnValue(true, string.Join("|", fileNames))); }
public async Task<IHttpActionResult> Post() { try { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); foreach (var file in provider.Contents.Where(x => x.Headers.ContentLength.HasValue && x.Headers.ContentLength.Value > 0)) { var fileName = file.Headers.ContentDisposition.FileName.Trim('\"'); var buffer = await file.ReadAsByteArrayAsync(); if(!Utilities.CanSaveFile(Utilities.DirectoryToSaveFiles, file.Headers.ContentLength.Value)) { return InternalServerError(); } File.WriteAllBytes(Path.Combine(Utilities.DirectoryToSaveFiles, fileName), buffer); } return Ok(); } catch(Exception e) { return InternalServerError(); } }
public async Task<FilesUploadResponse> UploadFiles() { List<FileDescription> newFiles = new List<FileDescription>(); if (!Request.Content.IsMimeMultipartContent()) throw new Exception(); // divided by zero var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); foreach (var file in provider.Contents) { var filename = file.Headers.ContentDisposition.FileName.Trim('\"'); var buffer = await file.ReadAsByteArrayAsync(); //Do whatever you want with filename and its binaray data. var id = Guid.NewGuid(); newFiles.Add(new FileDescription() { Id = id, Name = filename, Size = buffer.LongLength, Url = "#" }); } StaticFileStore.AddRange(newFiles); return new FilesUploadResponse { Files = newFiles }; }
public async Task<IHttpActionResult> Post() { if (!Request.Content.IsMimeMultipartContent()) { return BadRequest(); } var provider = new MultipartMemoryStreamProvider(); // путь к папке на сервере string root = System.Web.HttpContext.Current.Server.MapPath("~/UploadedFiles/"); await Request.Content.ReadAsMultipartAsync(provider); foreach (var file in provider.Contents) { var filename = file.Headers.ContentDisposition.FileName.Trim('\"'); byte[] fileArray = await file.ReadAsByteArrayAsync(); using (System.IO.FileStream fs = new System.IO.FileStream(root + filename, System.IO.FileMode.Create)) { await fs.WriteAsync(fileArray, 0, fileArray.Length); } var temp = users.GetById(Convert.ToInt32(User.Identity.Name)); temp.Photo = "UploadedFiles/" + filename; users.Edit(temp); } return Ok("OK"); }
public async Task<FormData> Convert(MultipartMemoryStreamProvider multipartProvider) { var multipartFormData = new FormData(); foreach (var file in multipartProvider.Contents.Where(x => IsFile(x.Headers.ContentDisposition))) { var name = UnquoteToken(file.Headers.ContentDisposition.Name); string fileName = FixFilename(file.Headers.ContentDisposition.FileName); string mediaType = file.Headers.ContentType.MediaType; using (var stream = await file.ReadAsStreamAsync()) { byte[] buffer = ReadAllBytes(stream); if (buffer.Length > 0) { multipartFormData.Add(name, new HttpFile(fileName, mediaType, buffer)); } } } foreach (var part in multipartProvider.Contents.Where(x => x.Headers.ContentDisposition.DispositionType == "form-data" && !IsFile(x.Headers.ContentDisposition))) { var name = UnquoteToken(part.Headers.ContentDisposition.Name); var data = await part.ReadAsStringAsync(); multipartFormData.Add(name, data); } return multipartFormData; }
public async Task MultipleRangesGeneratesMultipartByteRangesContent(string ranges, int innerStreamLength, int expectedBodyparts, string[] contentRanges) { // Arrange string data = new String('a', innerStreamLength); byte[] bytes = Encoding.UTF8.GetBytes(data); MemoryStream memStream = new MemoryStream(bytes); RangeHeaderValue range = RangeHeaderValue.Parse(ranges); // Act ByteRangeStreamContent content = new ByteRangeStreamContent(memStream, range, _expectedMediatype); MemoryStream result = new MemoryStream(); await content.CopyToAsync(result); MultipartMemoryStreamProvider multipart = await content.ReadAsMultipartAsync(); // Assert Assert.Equal(expectedBodyparts, multipart.Contents.Count); for (int count = 0; count < multipart.Contents.Count; count++) { MediaTypeHeaderValue contentType = multipart.Contents[count].Headers.ContentType; Assert.Equal(_expectedMediatype, contentType); ContentRangeHeaderValue expectedContentRange = ContentRangeHeaderValue.Parse(contentRanges[count]); ContentRangeHeaderValue contentRange = multipart.Contents[count].Headers.ContentRange; Assert.Equal(expectedContentRange, contentRange); } }
// POST: /api/videos public async Task<HttpResponseMessage> Post() { if (!Request.Content.IsMimeMultipartContent("form-data")) { throw new HttpResponseException(HttpStatusCode.NotAcceptable); } var streamProvider = new MultipartMemoryStreamProvider(); var provider = await Request.Content.ReadAsMultipartAsync(streamProvider); var videoInf = VideoInformation.Parse(provider.Contents); var validationErrors = videoInf.GetErrors(); var isValid = !validationErrors.Any(); if (isValid) { var video = await this.service.CreateVideoAsync( videoInf.Title, videoInf.Description, videoInf.FileInformation.Name, videoInf.FileInformation.Type, await videoInf.FileInformation.Data.ReadAsStreamAsync()); return Request.CreateResponse(HttpStatusCode.Created, video); } else { return Request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Join("\n", validationErrors)); } }
public async Task<IHttpActionResult> Post() { try { if (!Request.Content.IsMimeMultipartContent()) { return BadRequest("Not Mime Multipart Content"); } var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Upload"); foreach (var file in provider.Contents) { var fileName = Path.GetFileName(file.Headers.ContentDisposition.FileName.Trim('\"')); var fullPath = Path.Combine(path, fileName); var buffer = await file.ReadAsByteArrayAsync(); File.WriteAllBytes(fullPath, buffer); } return Ok(); } catch (Exception ex) { return InternalServerError(ex); } }
public async Task<HttpResponseMessage> Post() { if (!Request.Content.IsMimeMultipartContent()) { return Request.CreateErrorResponse(HttpStatusCode.UnsupportedMediaType, "please submit a valid request"); } var provider = new MultipartMemoryStreamProvider(); try { await Request.Content.ReadAsMultipartAsync(provider); var file = provider.Contents.FirstOrDefault(x => !string.IsNullOrEmpty(x.Headers.ContentDisposition.FileName)); if (file != null) { InitHttpClient(); var stream = file.ReadAsStreamAsync().Result; var filename = SaveFile(stream); var products = _excelReader.GetProductsFromFile(filename); var productsWithChangedProperties = FindProductsWithChangedProperties(products); return Request.CreateResponse(HttpStatusCode.OK, productsWithChangedProperties, "application/json"); } return Request.CreateErrorResponse(HttpStatusCode.NotFound, "Неверный файл"); } catch (System.Exception e) { return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e); } }
public async Task<HttpResponseMessage> UploadFile() { HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK); if (!Request.Content.IsMimeMultipartContent()) { response.StatusCode = HttpStatusCode.UnsupportedMediaType; } else { UserPrincipal loggedInUser = (UserPrincipal)HttpContext.Current.User; MultipartMemoryStreamProvider provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); Task<byte[]> fileData = provider.Contents.First().ReadAsByteArrayAsync(); string fileName = string.Format("{0}.jpg", Guid.NewGuid().ToString()); string directory = string.Format(@"{0}Uploads\{1}", AppDomain.CurrentDomain.BaseDirectory, loggedInUser.AccountSession.ClubId); if (!Directory.Exists(directory)) Directory.CreateDirectory(directory); using (FileStream fs = new FileStream(string.Format(@"{0}\{1}", directory, fileName), FileMode.OpenOrCreate)) { await fs.WriteAsync(fileData.Result, 0, fileData.Result.Length); fs.Close(); } response.Content = new ObjectContent<string>(fileName, new JsonMediaTypeFormatter()); } return response; }
// POST: api/SaveImages + ?id! //[Route("api/SaveImages/{id:int}")] public async Task<IHttpActionResult> PostSalonImage(int id, Boolean main, [FromUri]string username) { if (!ModelState.IsValid) { return BadRequest(ModelState); } // Check if the request contains multipart/form-data. if (Request.Content.IsMimeMultipartContent()) { var streamProvider = new MultipartMemoryStreamProvider(); streamProvider = await Request.Content.ReadAsMultipartAsync(streamProvider); foreach (var item in streamProvider.Contents.Where(c => !string.IsNullOrEmpty(c.Headers.ContentDisposition.FileName))) { Stream stPictureSource = new MemoryStream(await item.ReadAsByteArrayAsync()); // Resize for Picture MemoryStream stPictureDest = new MemoryStream(); var pictureSettings = new ResizeSettings { MaxWidth = 1000, MaxHeight = 1000, Mode = FitMode.Max }; ImageBuilder.Current.Build(stPictureSource, stPictureDest, pictureSettings); string fileName = item.Headers.ContentDisposition.FileName; fileName = fileName.Replace("\"", string.Empty); string ext = Path.GetExtension(fileName); string newFileName = Guid.NewGuid().ToString() + ext; File.WriteAllBytes(HostingEnvironment.MapPath("~/Images/SalonImages/" + newFileName), stPictureDest.ToArray()); db.SalonImages.Add(new SalonImage { AddedOn = DateTime.Now, CreateBy = username, ImageName = fileName, ImagePath = newFileName, IsDeleted = false, IsMain = main, SalonID = id, }); } await db.SaveChangesAsync(); return Ok(); } else { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } }
// POST api/values public async Task Post() { try { if (!Request.Content.IsMimeMultipartContent("form-data")) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var provider = new MultipartMemoryStreamProvider(); // Read the form data. await Request.Content.ReadAsMultipartAsync(provider); var fileName = DateTime.Now.ToString("yyyyMMdd-HHmmss"); var overlayText = string.Empty; var mediaType = string.Empty; var hubId = string.Empty; var username = string.Empty; byte[] bytes = null; foreach (var content in provider.Contents) { if (content.Headers.ContentDisposition.Name.Trim('"').Equals("textOverlay", StringComparison.InvariantCultureIgnoreCase)) { overlayText = await content.ReadAsStringAsync(); } else if (content.Headers.ContentDisposition.Name.Trim('"').Equals("hubid", StringComparison.InvariantCultureIgnoreCase)) { hubId = await content.ReadAsStringAsync(); } else if (content.Headers.ContentDisposition.Name.Trim('"').Equals("username", StringComparison.InvariantCultureIgnoreCase)) { username = await content.ReadAsStringAsync(); } else if (content.Headers.ContentDisposition.Name.Trim('"').Equals("file", StringComparison.InvariantCultureIgnoreCase)) { fileName += "-" + content.Headers.ContentDisposition.FileName.Trim('"'); mediaType = content.Headers.ContentType.MediaType; bytes = await content.ReadAsByteArrayAsync(); } } await new GifStorageService().StoreGifAsync( fileName, bytes, mediaType, new Dictionary<string, string> { { "UserName", username }, { "OverlayText", overlayText }, { "HubId", hubId } }); } catch (Exception) { throw; } }
public void ReadAsMultipartAsync_SingleLongBodyPart(string boundary, string singleLongBody) { HttpContent content = CreateContent(boundary, singleLongBody); MultipartMemoryStreamProvider result = content.ReadAsMultipartAsync().Result; Assert.Equal(1, result.Contents.Count); Assert.Equal(singleLongBody, result.Contents[0].ReadAsStringAsync().Result); ValidateContents(result.Contents); }
public async Task ReadAsMultipartAsync_SingleLongBodyPart(string boundary, string singleLongBody) { HttpContent content = CreateContent(boundary, singleLongBody); MultipartMemoryStreamProvider result = await content.ReadAsMultipartAsync(); Assert.Equal(1, result.Contents.Count); Assert.Equal(singleLongBody, await result.Contents[0].ReadAsStringAsync()); await ValidateContentsAsync(result.Contents); }
public async System.Threading.Tasks.Task<HttpResponseMessage> UploadFile([FromBody]string id) { var supportedTypes = new List<string> { "png", "jpg", "jpeg", "gif" }; if(!Request.Content.IsMimeMultipartContent()) { return Request.CreateErrorResponse(HttpStatusCode.UnsupportedMediaType, "The request doesn't contain valid content!"); } try { var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); string fileName = ""; string fullpath = ""; var file = provider.Contents.FirstOrDefault(); if(file != null) { if(string.IsNullOrEmpty(file.Headers.ContentDisposition.FileName)) throw new ArgumentNullException("file", "Invalid file provided!"); var serverPath = System.Web.HttpContext.Current.Server.MapPath("~/Images/Profile"); fileName = GetFileName(serverPath, file.Headers); var ext = Path.GetExtension(fileName); if(!supportedTypes.Contains(ext.Trim().TrimStart('.'))) throw new ArgumentException("Provided file type is not supported!"); fullpath = Path.Combine(serverPath, Path.GetFileName(fileName)); var dataStream = await file.ReadAsStreamAsync(); using(var fileStream = File.Create(fullpath)) { dataStream.Seek(0, System.IO.SeekOrigin.Begin); dataStream.CopyTo(fileStream); } } var dbHelper = new MySqlPomocnik(); //dbHelper.IzvrsiProceduru(new SqlUpit(), new Dictionary<string,object>()); var response = Request.CreateResponse(HttpStatusCode.OK); response.Content = new StringContent(JSONHelper.ToJSON(new { fileName = fileName }), Encoding.UTF8, "text/plain"); response.Content.Headers.ContentType = new MediaTypeWithQualityHeaderValue(@"text/html"); return response; } catch(Exception e) { return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e.Message); } }
public async Task ReadAsMultipartAsync_MultipleShortBodyParts(string boundary, string[] multipleShortBodies) { HttpContent content = CreateContent(boundary, multipleShortBodies); MultipartMemoryStreamProvider result = await content.ReadAsMultipartAsync(); Assert.Equal(multipleShortBodies.Length, result.Contents.Count); for (var check = 0; check < multipleShortBodies.Length; check++) { Assert.Equal(multipleShortBodies[check], await result.Contents[check].ReadAsStringAsync()); } await ValidateContentsAsync(result.Contents); }
public void ReadAsMultipartAsync_MultipleLongBodyParts(string boundary, string[] multipleLongBodies) { HttpContent content = CreateContent(boundary, multipleLongBodies); MultipartMemoryStreamProvider result = content.ReadAsMultipartAsync(new MultipartMemoryStreamProvider(), ParserData.MinBufferSize).Result; Assert.Equal(multipleLongBodies.Length, result.Contents.Count); for (var check = 0; check < multipleLongBodies.Length; check++) { Assert.Equal(multipleLongBodies[check], result.Contents[check].ReadAsStringAsync().Result); } ValidateContents(result.Contents); }
public void ReadAsMultipartAsync_WithHugeBody_AvoidStackOverflow() { // Arrange var fiftyMegs = 1024 * 1024 * 50; HttpContent content = CreateContent("---3123---", new string('x', fiftyMegs)); // Act MultipartMemoryStreamProvider result = content.ReadAsMultipartAsync(new MultipartMemoryStreamProvider(), 256).Result; // Assert // this is for sanity. The actual test here is that the Act part did not cause a stack overflow Assert.Equal(fiftyMegs, result.Contents[0].ReadAsStringAsync().Result.Length); ValidateContents(result.Contents); }
public async Task<IHttpActionResult> PostOpenFile() { var streamProvider = new MultipartMemoryStreamProvider(); var multipartFileStreamProvider = await Request.Content.ReadAsMultipartAsync(streamProvider); if (multipartFileStreamProvider.Contents.Count == 0) { return BadRequest(); } var fileName = streamProvider.Contents.First().Headers.ContentDisposition.FileName.Trim('"'); var content = await streamProvider.Contents.First().ReadAsByteArrayAsync(); var dataContainer = await _dataContainerConverterService.ToDataContainer(content, fileName); return Ok(dataContainer); }
public void ReadAsMultipartAsync_MultipleShortBodyParts(string boundary) { string[] text = new string[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" }; HttpContent content = CreateContent(boundary, text); MultipartMemoryStreamProvider result = content.ReadAsMultipartAsync().Result; Assert.Equal(text.Length, result.Contents.Count); for (var check = 0; check < text.Length; check++) { Assert.Equal(text[check], result.Contents[check].ReadAsStringAsync().Result); } ValidateContents(result.Contents); }
public void GetStreamReturnsMemoryStream() { MultipartMemoryStreamProvider instance = MultipartMemoryStreamProvider.Instance; HttpContent content = new StringContent("text"); Stream stream = instance.GetStream(content.Headers); Assert.NotNull(stream); MemoryStream memStream = stream as MemoryStream; Assert.NotNull(stream); Assert.Equal(0, stream.Length); Assert.Equal(0, stream.Position); Assert.NotSame(memStream, instance.GetStream(content.Headers)); }
public async Task Put(int id, HttpRequestMessage request) { if (!Request.Content.IsMimeMultipartContent()) throw new InvalidOperationException(); var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); var file = provider.Contents.First(); var filename = file.Headers.ContentDisposition.FileName.Trim('\"'); var buffer = await file.ReadAsByteArrayAsync(); var stream = new MemoryStream(buffer); using (var s = new StreamReader(stream)) { var test = s; } }
public async Task<HttpResponseMessage> ImportDatabase(int batchSize, bool includeExpiredDocuments, ItemType operateOnTypes, string filtersPipeDelimited, string transformScript) { if (!this.Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var streamProvider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(streamProvider); var fileStream = await streamProvider.Contents .First(c => c.Headers.ContentDisposition.Name == "\"file\"") .ReadAsStreamAsync(); var dataDumper = new DataDumper(Database); var importOptions = new SmugglerImportOptions { FromStream = fileStream }; var options = new SmugglerOptions { BatchSize = batchSize, ShouldExcludeExpired = includeExpiredDocuments, OperateOnTypes = operateOnTypes, TransformScript = transformScript }; // Filters are passed in without the aid of the model binder. Instead, we pass in a list of FilterSettings using a string like this: pathHere;;;valueHere;;;true|||againPathHere;;;anotherValue;;;false // Why? Because I don't see a way to pass a list of a values to a WebAPI method that accepts a file upload, outside of passing in a simple string value and parsing it ourselves. if (filtersPipeDelimited != null) { options.Filters.AddRange(filtersPipeDelimited .Split(new string[] { "|||" }, StringSplitOptions.RemoveEmptyEntries) .Select(f => f.Split(new string[] { ";;;" }, StringSplitOptions.RemoveEmptyEntries)) .Select(o => new FilterSetting { Path = o[0], Values = new List<string> { o[1] }, ShouldMatch = bool.Parse(o[2]) })); } await dataDumper.ImportData(importOptions, options); return GetEmptyMessage(); }
public async Task<HttpResponseMessage> Post() { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } // Temp storage location for File Chunks MultipartMemoryStreamProvider provider = new MultipartMemoryStreamProvider(); FileChunk chunk = null; try { // Read all contents of multipart message into MultipartMemoryStreamProvider. await Request.Content.ReadAsMultipartAsync(provider); using (Stream fileChunkStream = await provider.Contents[0].ReadAsStreamAsync()) { //Check for not null or empty if (fileChunkStream == null) throw new HttpResponseException(HttpStatusCode.NotFound); // Read file chunk detail chunk = provider.Contents[0].Headers.GetMetaData(); chunk.ChunkData = fileChunkStream.ReadFully(); // Upload Chunk to blob storage and store the reference in Azure Cache _operations.UploadChunk(chunk); // check for last chunk, if so, then do a PubBlockList // Remove all keys of that FileID from Dictionary if (chunk.IsCompleted) _operations.CommitChunks(chunk); } // Send OK Response along with saved file names to the client. return Request.CreateResponse(HttpStatusCode.OK); } catch (System.Exception e) { return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e); } }
public async Task<HttpResponseMessage> ImportDatabase() { if (!this.Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var streamProvider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(streamProvider); var fileStream = await streamProvider.Contents.First().ReadAsStreamAsync(); var dataDumper = new DataDumper(Database); var importOptions = new SmugglerImportOptions { FromStream = fileStream }; var options = new SmugglerOptions(); await dataDumper.ImportData(importOptions, options); return GetEmptyMessage(); }
public void ReadAsMultipartAsync_MultipleLongBodyParts(string boundary) { string[] text = new string[] { "A" + LongText + "A", "B" + LongText + "B", "C" + LongText + "C", "D" + LongText + "D", "E" + LongText + "E", "F" + LongText + "F", "G" + LongText + "G", "H" + LongText + "H", "I" + LongText + "I", "J" + LongText + "J", "K" + LongText + "K", "L" + LongText + "L", "M" + LongText + "M", "N" + LongText + "N", "O" + LongText + "O", "P" + LongText + "P", "Q" + LongText + "Q", "R" + LongText + "R", "S" + LongText + "S", "T" + LongText + "T", "U" + LongText + "U", "V" + LongText + "V", "W" + LongText + "W", "X" + LongText + "X", "Y" + LongText + "Y", "Z" + LongText + "Z" }; HttpContent content = CreateContent(boundary, text); MultipartMemoryStreamProvider result = content.ReadAsMultipartAsync(new MultipartMemoryStreamProvider(), ParserData.MinBufferSize).Result; Assert.Equal(text.Length, result.Contents.Count); for (var check = 0; check < text.Length; check++) { Assert.Equal(text[check], result.Contents[check].ReadAsStringAsync().Result); } ValidateContents(result.Contents); }
public async Task<IHttpActionResult> MyFileUpload () { var test = Request.GetQueryNameValuePairs(); var id = test.First(f => f.Key == "id").Value.ToInt(); if(!Request.Content.IsMimeMultipartContent()) throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); foreach(var file in provider.Contents) { var filename = file.Headers.ContentDisposition.FileName.Trim('\"'); var buffer = await file.ReadAsByteArrayAsync(); await usersBl.UpdateImage(id,filename,buffer); } return Ok(true); }
// POST api/convertFiles?outputFormat=twl public async Task<IHttpActionResult> PostConvertFile(string outputFormat) { var streamProvider = new MultipartMemoryStreamProvider(); var multipartFileStreamProvider = await Request.Content.ReadAsMultipartAsync(streamProvider); if (multipartFileStreamProvider.Contents.Count == 0) { return BadRequest(); } var inputFormat = ConvertExtenstionToFormat(Path.GetExtension(streamProvider.Contents.First().Headers.ContentDisposition.FileName.Trim('\"'))); var content = await streamProvider.Contents.First().ReadAsByteArrayAsync(); if (outputFormat.Equals("geojson", StringComparison.InvariantCultureIgnoreCase)) { var convertedGpx = await _gpsBabelGateway.ConvertFileFromat(content, inputFormat, ConvertExtenstionToFormat(".gpx")); var featureCollection = ConvertGpxContentToGeoJson(convertedGpx); return Ok(featureCollection); } var outputContent = await _gpsBabelGateway.ConvertFileFromat(content, inputFormat, outputFormat); return Ok(outputContent); }
public async Task<IHttpActionResult> PostFormData() { var claimsIdentity = User.Identity as ClaimsIdentity; if (claimsIdentity == null) return InternalServerError(); // Check if the request contains multipart/form-data. if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); var url = await _uploadControllerService.UploadImage(provider.Contents); await _uploadControllerService.UpdateUserImage(claimsIdentity.GetUserId(), url); return Ok(url); }
private async Task<RemoteFileFetcherGatewayResponse> GetFile(string url) { if (string.IsNullOrEmpty(url) == false) { var fetcher = _httpGatewayFactory.CreateRemoteFileFetcherGateway(_cache.Get(User.Identity.Name)); return await fetcher.GetFileContent(url); } var streamProvider = new MultipartMemoryStreamProvider(); var multipartFileStreamProvider = await Request.Content.ReadAsMultipartAsync(streamProvider); if (multipartFileStreamProvider.Contents.Count == 0) { return new RemoteFileFetcherGatewayResponse(); } return new RemoteFileFetcherGatewayResponse { Content = await streamProvider.Contents.First().ReadAsByteArrayAsync(), FileName = streamProvider.Contents.First().Headers.ContentDisposition.FileName.Trim('"') }; }
public async Task<HttpResponseMessage> PostFile() { if (!Request.Content.IsMimeMultipartContent()) throw new Exception(); var provider = new MultipartMemoryStreamProvider(); var result = new { files = new List<object>() }; provider = await Request.Content.ReadAsMultipartAsync(provider); var file = provider.Contents.FirstOrDefault(); if (file == null) return Request.CreateResponse(HttpStatusCode.BadRequest); var reading = await file.ReadAsByteArrayAsync(); var stream = new MemoryStream(reading); var response = _validator.Validate(XElement.Load(stream)); return !response.Successful ? Request.CreateResponse(HttpStatusCode.BadRequest, response.Errors) : Request.CreateResponse(HttpStatusCode.OK); }
public async Task 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>(async(type, stream, content, logger) => { MultipartMemoryStreamProvider provider = await content.ReadAsMultipartAsync(); Assert.Equal(1, provider.Contents.Count); return(await provider.Contents[0].ReadAsStringAsync()); }); MediaTypeFormatter formatter = _formatterMock.Object; formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("multipart/mixed")); Assert.Equal("multipartContent", await mimeContent.ReadAsAsync <string>(new[] { formatter })); }
public async Task<IHttpActionResult> StoreImage() { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } // TODO check size and type var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); var res = new List<ItemInfo>(); foreach (var file in provider.Contents) { var filename = file.Headers.ContentDisposition.FileName.Trim('\"'); var ext = Path.GetExtension(filename).TrimStart('.'); var stream = await file.ReadAsStreamAsync(); res.Add(this.mediaService.StoreImage(stream, ext)); } return this.Ok(res); }
public async Task<HttpResponseMessage> ImportExcelFile() { HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK); if (!Request.Content.IsMimeMultipartContent()) { response.StatusCode = HttpStatusCode.UnsupportedMediaType; } else { MultipartMemoryStreamProvider provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); Task<byte[]> fileData = provider.Contents.First().ReadAsByteArrayAsync(); int formId = int.Parse(((System.Web.HttpContextWrapper)Request.Properties["MS_HttpContext"]).Request.Form["formId"]); FormExcelImportResult result = FormsBLL.SubmitExternalFormFromExcel(fileData.Result, formId); response.Content = new ObjectContent<FormExcelImportResult>(result, new JsonMediaTypeFormatter()); } return response; }
public async Task 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(); await innerContent.CopyToAsync(memStream); 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 = await content.ReadAsMultipartAsync(); Assert.Equal(1, result.Contents.Count); content = result.Contents[0]; Assert.NotNull(content); } string text = await content.ReadAsStringAsync(); Assert.Equal(innerText, text); }
public async Task 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(); await content.CopyToAsync(memStream); memStream.Position = 0; byte[] data = memStream.ToArray(); var byteContent = new ByteArrayContent(data); byteContent.Headers.ContentType = content.Headers.ContentType; MultipartMemoryStreamProvider result = await byteContent.ReadAsMultipartAsync(); Assert.Equal(3, result.Contents.Count); Assert.Equal("A", await result.Contents[0].ReadAsStringAsync()); Assert.Equal("B", await result.Contents[1].ReadAsStringAsync()); Assert.Equal("C", await result.Contents[2].ReadAsStringAsync()); }
public void DefaultConstructor() { MultipartMemoryStreamProvider instance = MultipartMemoryStreamProvider.Instance; Assert.NotNull(instance); }
public void GetStreamThrowsOnNull() { MultipartMemoryStreamProvider instance = MultipartMemoryStreamProvider.Instance; Assert.ThrowsArgumentNull(() => { instance.GetStream(null); }, "headers"); }