public static string getDataInRequest(HttpRequestMessage Request) { string ret = ""; bool Rslt = false; MultipartMemoryStreamProvider prvdr = new MultipartMemoryStreamProvider(); Task readData = Request.Content.ReadAsMultipartAsync(prvdr).ContinueWith((readTask) => { Rslt = readTask.IsCompleted; }); readData.Wait(); if (Rslt) { foreach (HttpContent ctnt in prvdr.Contents) { // You would get hold of the inner memory stream here Stream stream = ctnt.ReadAsStreamAsync().Result; var sr = new StreamReader(stream); var myStr = sr.ReadToEnd(); if (myStr != null && !myStr.Equals("")) { ret = Utility.Decrypt(myStr, true, Config.SECURITY_KEY); break; } } } return(ret); }
public async Task <ElementResponse> AddVideoForNews() { if (!Request.Content.IsMimeMultipartContent()) { throw new ApplicationException("Ошибка загрузки видео"); } var provider = new MultipartMemoryStreamProvider(); string root = HttpContext.Current.Server.MapPath("~/Files/Video/News/"); await Request.Content.ReadAsMultipartAsync(provider); var file = provider.Contents[0]; byte[] fileArray = await file.ReadAsByteArrayAsync(); var newsId = file.Headers.ContentDisposition.FileName.Trim('\"'); Random rnd = new Random(); var code = rnd.Next(1000, 10001); var filename = newsId + code + ".mp4"; var urlDir = root + filename; var urlBd = $"./Files/Video/News/{filename}"; DelVideoNewsBLL.Execute(newsId); using (FileStream fs = new FileStream(urlDir, FileMode.Create)) { await fs.WriteAsync(fileArray, 0, fileArray.Length); } return(AddVideoForNewsBLL.Execute(newsId, urlDir, urlBd)); }
public async Task <HttpResponseMessage> UploadGenres() { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var provider = new MultipartMemoryStreamProvider(); await this.Request.Content.ReadAsMultipartAsync(provider); var httpContent = provider.Contents[0]; if (!ValidContentTypes.Contains(httpContent.Headers.ContentType.ToString())) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var csvData = await httpContent.ReadAsStreamAsync(); var result = this._genreService.ImportGenreConfig(csvData); if (!result) { throw new Exception("Error in parsing files"); } var response = this.Request.CreateResponse(HttpStatusCode.OK, new { Status = "Success" }); response.Content.Headers.ContentType = new MediaTypeHeaderValue("text/plain"); return(response); }
public async Task <System.Web.Http.IHttpActionResult> UpdateImage() { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var user = User.Identity.Name; var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); var fileManager = new AzureFileManager(); 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 binary data. var result = fileManager.UploadFileAsync(buffer, $"{user}.png");//pass file stream if (!string.IsNullOrEmpty(result.Result)) { return(BadRequest(result.Result)); } } return(Ok()); }
///<summary> ///<remarks>If FILES_TO_FILESYSTEM is not defined - be aware of max_allowed_packet limit in MySQL.</remarks> ///</summary> #if FILES_TO_FILESYSTEM public async Task <SystemException> PutFiles(MultipartMemoryStreamProvider inFileStream, long inArticleId, string inBasePath) { try { foreach (HttpContent fileInfo in inFileStream.Contents) { FileStream fileStream = new FileStream(inBasePath + $"\\{inArticleId}\\" + fileInfo. Headers. ContentDisposition. FileName. Replace("\"", string.Empty), FileMode.Create); await fileInfo.CopyToAsync(fileStream); fileStream.Close(); } } catch (SystemException error) { return(error); } return(null); }
public static async Task <HttpPostedData> ParseMultipartAsync(this HttpContent postedContent) { var provider = new MultipartMemoryStreamProvider(); var files = new Dictionary <string, HttpPostedFile>(StringComparer.InvariantCultureIgnoreCase); var fields = new Dictionary <string, HttpPostedField>(StringComparer.InvariantCultureIgnoreCase); try { provider = await postedContent.ReadAsMultipartAsync(); //files = new Dictionary<string, HttpPostedFile>(StringComparer.InvariantCultureIgnoreCase); //fields = new Dictionary<string, HttpPostedField>(StringComparer.InvariantCultureIgnoreCase); foreach (var content in provider.Contents) { var fieldName = content.Headers.ContentDisposition.Name.Trim('"'); if (!string.IsNullOrEmpty(content.Headers.ContentDisposition.FileName)) { var file = await content.ReadAsByteArrayAsync(); var fileName = content.Headers.ContentDisposition.FileName.Trim('"'); files.Add(fieldName, new HttpPostedFile(fieldName, fileName, file)); } else { var data = await content.ReadAsStringAsync(); fields.Add(fieldName, new HttpPostedField(fieldName, data)); } } } catch (Exception ex) { string str = ex.Message; } return(new HttpPostedData(fields, files)); }
public async Task <HttpResponseMessage> Upload(int id, string type) { // Check if the request contains multipart/form-data. if (!Request.Content.IsMimeMultipartContent("form-data")) { return(new HttpResponseMessage(HttpStatusCode.BadRequest)); } //If size of a file is not big then read file directly into stream var streamProvider = new MultipartMemoryStreamProvider(); //If size is quite big to upload then store file to desk and then move to appropriate directory //var streamProvider = new MultipartFormDataStreamProvider(sourcePath); await Request.Content.ReadAsMultipartAsync(streamProvider); List <HttpContent> streamContent = streamProvider.Contents.ToList(); /*foreach (HttpContent ctnt in streamProvider.Contents) * { * using (Stream stream = ctnt.ReadAsStreamAsync().Result) * { * stream.Seek(0, SeekOrigin.Begin); * FileStream filestream = File.Create(remotePath+ "/"+ctnt.Headers.ContentDisposition.FileName.Replace("\"", string.Empty)); * * stream.CopyTo(filestream); * stream.Close(); * filestream.Close(); * } * }*/ string contenttype = streamContent.ToList().Select(p => p.Headers.ContentType).FirstOrDefault().MediaType; HttpResponseMessage resMessage = requestHandler.CreateGbDocObject(Request, id, type, streamContent, sourcePath); return(resMessage); }
/// <summary> /// Converts the <see cref="MultipartStreamProvider.Contents"/> of the provided <paramref name="multipartProvider"/> to multi-part form-data. /// </summary> 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 <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 static async Task <IEnumerable <string> > UploadFiles(HttpRequestMessage request, string uploadFolder) { if (!request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var root = System.Web.HttpContext.Current.Server.MapPath("~/" + uploadFolder.Replace(".", "/").Replace("\\", "/")); Directory.CreateDirectory(root); var provider = new MultipartMemoryStreamProvider(); await request.Content.ReadAsMultipartAsync(provider); var fileNames = new List <string>(); foreach (var file in provider.Contents) { var fileName = file.Headers.ContentDisposition.FileName.Trim('\"'); fileNames.Add(fileName); using (var contentStream = await file.ReadAsStreamAsync()) using (var fileStream = new FileStream(root + "//" + fileName, FileMode.Create)) { await contentStream.CopyToAsync(fileStream); } } return(fileNames); }
public async Task <IHttpActionResult> UploadProductImages() { List <ProductImage> images = new List <ProductImage>(); if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } try { var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); foreach (var file in provider.Contents) { if (file.Headers.ContentLength > 0) { ProductImage image = new ProductImage(); image.Image = await file.ReadAsByteArrayAsync(); image.FileType = file.Headers.ContentType.MediaType; image.FileName = file.Headers.ContentDisposition.FileName.Trim('\"'); //File.WriteAllBytes(imagePath, buffer); images.Add(image); } } SessionManager.Current.ProductImages = images; return(Ok()); } catch (Exception ex) { var response = Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex); throw new HttpResponseException(response); } }
public async Task <IHttpActionResult> CalculateRoute(string algorithm, int origin, int destination) { if (!Request.Content.IsMimeMultipartContent()) { return(StatusCode(HttpStatusCode.UnsupportedMediaType)); } var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); if (provider.Contents.Count == 0) { return(BadRequest("You have to add file with matrix for procesing")); } var parsedMatrix = await GetMatrixAsync(provider); if (!parsedMatrix.Validate() || !ValidateBoundaryPoints(origin, destination, parsedMatrix.Count)) { return(StatusCode((HttpStatusCode)422)); } var matrix = parsedMatrix.ToSquareMatrix(); Route route = _routeService.CalculateRoute(matrix, origin - 1, destination - 1, algorithm); return(Ok(route)); }
public async Task <IHttpActionResult> Upload() { var usrId = User.Identity.GetUserId(); string token; string secret; using (var db = new ApplicationDbContext()) { var usr = db.Users.Where(u => u.Id == usrId).Single(); token = usr.MeoCloudAPIToken; secret = usr.MeoCloudAPISecret; } 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.Replace("\"", string.Empty); var buffer = await file.ReadAsByteArrayAsync(); var result = await new MeoCloudProvider(token, secret).UploadFile(filename, buffer); } return(Ok()); }
public async Task <Guid> Create() { Guid?Id = null; if (Request.Content.IsMimeMultipartContent()) { MultipartMemoryStreamProvider provider = await Request.Content .ReadAsMultipartAsync <MultipartMemoryStreamProvider>(new MultipartMemoryStreamProvider()); foreach (HttpContent content in provider.Contents) { Stream stream = content.ReadAsStreamAsync().Result; Image image = Image.FromStream(stream); String filePath = HostingEnvironment.MapPath("~/Content/Images"); Id = Guid.NewGuid(); string imageName = Id.ToString() + ".jpg"; String fullPath = Path.Combine(filePath, imageName); image.Save(fullPath); imageService.CreatePhoto(Id.Value, fullPath); //only one!!! break; } } return(Id.Value); }
public async Task <UploadModel> Post() { var uploadService = InjectorManager.GetInstance <UploadArquivoService>(); UploadModel model = null; var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider). ContinueWith(o => { var fileContent = provider.Contents.SingleOrDefault(); if (fileContent != null) { var fileName = fileContent.Headers.ContentDisposition.FileName.Replace("\"", string.Empty); var type = fileContent.Headers.ContentType.MediaType; var blob = fileContent.ReadAsByteArrayAsync().Result; var stream = fileContent.ReadAsStreamAsync().Result; var upload = ImageService.ResizeAndCompress(stream); model = uploadService.SalvarArquivo(upload); } }); return(model); }
public async Task <HttpResponseMessage> Upload() { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); var idList = new List <Guid>(MaxUploadCount); foreach (var file in provider.Contents.Take(MaxUploadCount)) { var fileName = file.Headers.ContentDisposition.FileName.Trim('\"'); var buffer = await file.ReadAsByteArrayAsync(); var tempFile = new TempFile { Id = Guid.NewGuid(), FileName = fileName, FileBytes = buffer }; cacheService.GetOrSet(tempFile.Id.ToString(), () => tempFile, DateTimeOffset.Now.AddDays(1)); idList.Add(tempFile.Id); } var result = string.Join(",", idList); return(Request.CreateResponse(HttpStatusCode.OK, result)); }
public async Task <IHttpActionResult> AddTempPhoto() { if (!Request.Content.IsMimeMultipartContent()) { return(BadRequest()); } var provider = new MultipartMemoryStreamProvider(); // путь к папке на сервере var root = HttpContext.Current.Server.MapPath("/StoreImages/Temp/"); await Request.Content.ReadAsMultipartAsync(provider); foreach (var file in provider.Contents) { var filename = file.Headers.ContentDisposition.FileName.Trim('\"'); filename = Path.GetFileName(filename); var fileArray = await file.ReadAsByteArrayAsync(); try { using (var fs = new FileStream(root + filename, FileMode.Create)) { await fs.WriteAsync(fileArray, 0, fileArray.Length); } } catch (Exception) { //ignored; } } return(Ok()); }
public void AddScreenShot(int ProductID) { var result = new HttpResponseMessage(HttpStatusCode.OK); if (Request.Content.IsMimeMultipartContent()) { Request.Content.ReadAsMultipartAsync <MultipartMemoryStreamProvider>(new MultipartMemoryStreamProvider()).ContinueWith((task) => { MultipartMemoryStreamProvider provider = task.Result; foreach (HttpContent content in provider.Contents) { Stream stream = content.ReadAsStreamAsync().Result; var image = (Bitmap)Bitmap.FromStream(stream); Product product = db.Products.Find(ProductID); var z = image.ImageToByteArray(); product.Screenshots.Add(new Screenshot { ScreenShot1 = z }); db.SaveChanges(); } }); return; } else { throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted")); } }
public async Task <HttpResponseMessage> Post() { var id = Request.Headers.GetValues("studentId").FirstOrDefault(); var name = Request.Headers.GetValues("studentName").FirstOrDefault(); // 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))) { MemoryStream ms = new MemoryStream(await item.ReadAsByteArrayAsync()); string path = HttpContext.Current.Server.MapPath("~/photos/diploma"); var fileName = item.Headers.ContentDisposition.FileName.Replace("\"", string.Empty).Trim(); var extension = fileName.Split('.').LastOrDefault(); fileName = name + "--" + id + "." + extension; FileStream file = new FileStream(path + "\\" + fileName, FileMode.Create, FileAccess.Write); ms.WriteTo(file); file.Close(); ms.Close(); int studentId; int.TryParse(id, out studentId); updateImageUrlCommandHandler.Execute(new Student { Id = studentId, ImageUrl = "/photos/diploma/" + fileName }); } } return(Request.CreateResponse(HttpStatusCode.OK, new { Message = "Student registration successful. Please note down student id generated is: " + id, Id = id })); //return Request.CreateResponse(HttpStatusCode.OK, new { message = name+ ", " + id}); }
public async Task <System.Dynamic.ExpandoObject> HttpContentToVariables(MultipartMemoryStreamProvider req) { dynamic res = new System.Dynamic.ExpandoObject(); foreach (HttpContent contentPart in req.Contents) { var contentDisposition = contentPart.Headers.ContentDisposition; string varname = contentDisposition.Name; if (varname == "\"BranchesId\"") { res.BranchesId = contentPart.ReadAsStringAsync().Result; } else if (varname == "\"file\"") { Stream stream = await contentPart.ReadAsStreamAsync(); res.fileName = String.IsNullOrEmpty(contentDisposition.FileName) ? "" : contentDisposition.FileName.Trim('"'); res.excelStream = stream; } else if (varname == "\"startDate\"") { res.startDate = contentPart.ReadAsStringAsync().Result; } else if (varname == "\"endDate\"") { res.endDate = contentPart.ReadAsStringAsync().Result; } } return(res); }
// 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 <HttpResponseMessage> Post() { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } try { var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); var file = provider.Contents.FirstOrDefault(x => x.Headers.ContentType != null); var buffer = await file.ReadAsByteArrayAsync(); var contentType = file.Headers.ContentType.ToString(); var name = file.Headers.ContentDisposition.FileName.Replace("\"", ""); var mediaId = _mediaLogic.Create(buffer, contentType, name); var response = Request.CreateResponse(HttpStatusCode.OK, mediaId.ToString()); return(response); } catch (Exception e) { return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e)); } }
public async Task <IHttpActionResult> Post() { try { // The work-around in handling files being uploaded via ajax post (thanks Microsoft) var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); // extract file name and file contents var fileNameParam = provider.Contents[0].Headers.ContentDisposition.Parameters .FirstOrDefault(p => p.Name.ToLower() == "filename"); var fileName = fileNameParam?.Value.Trim('"') ?? ""; var file = await provider.Contents[0].ReadAsStreamAsync(); if (file.Length == 0 || string.IsNullOrEmpty(fileName)) { return(BadRequest("No file was provided")); } //Get the input S3 bucket name set on the pipeline config var piplineResponse = _transcoderService.Pipeline(); //Create unique key and use that for the file being uploaded var key = Guid.NewGuid().ToString(); var fileNameKey = key + Path.GetExtension(fileName); _storageService.UploadFile(file, fileNameKey, piplineResponse.Pipeline.InputBucket); return(Ok(fileNameKey)); //return unique so it can be used for the job. } catch (Exception ex) { return(InternalServerError(ex)); } }
public async Task <IHttpActionResult> UploadBackup() { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); //TODO get all uploaded files var fileName = provider.Contents[0].Headers.ContentDisposition.FileName.Trim('\"'); var buffer = await provider.Contents[0].ReadAsByteArrayAsync(); if (fileName.EndsWith("bak")) { string filePath = Path.Combine(backupFilePath, fileName); //TODO: check if there is not yet a file with same name... try { File.WriteAllBytes(filePath, buffer); return(Ok("Backup successfully uploaded")); } catch (Exception ex) { return(InternalServerError(ex)); } } return(BadRequest("Error in uploading file. Not correct extension.")); }
public async Task <IHttpActionResult> SaveLuggageDocuments(int id) { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } try { 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(); File.WriteAllBytes(System.Web.HttpContext.Current.Server.MapPath(@"~/DocumentsFirstNoticeOfLoss/LuggageInsurance/" + fileName), buffer); var document = new document(); document.Name = fileName; var documentID = _fis.AddDocument(document); _fis.AddDocumentToFirstNoticeOfLoss(documentID, id); } return(Ok()); } catch (Exception e) { throw new Exception("Internal error: Not saved"); } }
protected async Task <Dictionary <string, object> > MultipartFormData() { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); var formParams = new Dictionary <string, object>(); foreach (var content in provider.Contents) { var isFile = content.Headers.ContentType != null && !content.Headers.ContentType.MediaType.StartsWith("text"); var paramName = content.Headers.ContentDisposition.Name.Replace("\"", ""); if (isFile) { var fileData = await content.ReadAsByteArrayAsync(); var fileName = Entities.File.Save(content.Headers.ContentDisposition.FileName.Replace("\"", ""), fileData); formParams[paramName] = fileName; } else { formParams[paramName] = await content.ReadAsStringAsync(); } } return(formParams); }
public async Task <HttpResponseMessage> Upload() { if (!Request.Content.IsMimeMultipartContent()) { return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, new Exception("Unsupported Media Type"))); } var streamProvider = new MultipartMemoryStreamProvider(); try { await Request.Content.ReadAsMultipartAsync(streamProvider); foreach (var mediaData in streamProvider.Contents.Select( file => new MediaData { Id = new Guid(FormatFileName(file.Headers.ContentDisposition.FileName)), Data = new MemoryStream(file.ReadAsByteArrayAsync().Result), })) { _mediaDataService.UploadMediaData(mediaData); } return(Request.CreateResponse(HttpStatusCode.OK)); } catch (Exception exception) { return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exception)); } }
public void ShouldRetrieveEmptyBodyPartFileNames() { var provider = new MultipartMemoryStreamProvider(); provider.BodyPartFileNames.Add("key1", "value1"); Assert.AreEqual(provider.BodyPartFileNames.Count, 0); }
//public string TalkToStream(HttpPostedFile) public async Task <IHttpActionResult> TalkToStream() { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); var file = provider.Contents[0]; var filename = file.Headers.ContentDisposition.FileName.Trim('\"'); var fileType = filename.Split('.').Last(); var buffer = await file.ReadAsByteArrayAsync(); //Do whatever you want with filename and its binary data. var fullFile = $@"{MainForm.liveAudioFolder}\{Guid.NewGuid()}.{fileType}"; File.WriteAllBytes(fullFile, buffer); Service.audioHandler.ProcessCommand(AudioCommand.PlayLiveVoice, fullFile); return(Ok()); }
public virtual async Task <List <string> > PostToMemory() { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted")); } var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); var contents = new List <string>(); foreach (HttpContent ctnt in provider.Contents) { var stream = await ctnt.ReadAsStreamAsync(); if (stream.Length != 0) { var sr = new StreamReader(stream); contents.Add(sr.ReadToEnd()); } } return(contents); }
public async Task <IHttpActionResult> PostKnnTrainingFile() { StoreysHandler SH = new StoreysHandler(db); SpacesHandler SpH = new SpacesHandler(db); KnnsHandler KH = new KnnsHandler(db); var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); var file = provider.Contents[0]; string filename = file.Headers.ContentDisposition.FileName.Trim('\"'); //Bytes from the binary reader stored in BlobValue array byte[] TrainingSet = file.ReadAsByteArrayAsync().Result; //reader.ReadBytes((int)file.Length); string trainingString = System.Text.Encoding.UTF8.GetString(TrainingSet); //KVP<LabelMap, knnByte>,First label ID> KeyValuePair <KeyValuePair <byte[], byte[]>, string> LabelMapKnn = KnnGenerate.GenerateTemplateTrainingFile(trainingString); //Generate the files from the generate template method within the template method. save those 3 to db //Storey storey = BC.GetBeaconStorey(BeaconID); //Knn knn = new Knn(); //Once trainingSets generated, Space Guid will be saved in the LabelMapKnn string. Guid storeyId = SpH.GetSpaceStorey(Guid.Parse(LabelMapKnn.Value)).ID; Storey storey = SH.GetStorey(storeyId); byte[] LabelMap = LabelMapKnn.Key.Value; byte[] Knn = LabelMapKnn.Key.Key; Knn knn = new Knn(storey, TrainingSet, LabelMap, Knn); KH.PostKnn(knn); return(Ok(storey)); }
public async Task<IHttpActionResult> Post() { 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(); //Do whatever you want with filename and its binaray data. } return Ok(); }
public void ShouldThrowOnNullContentDisposition() { var content = new StreamContent(new MemoryStream()); var provider = new MultipartMemoryStreamProvider(); bool thrown = false; try { provider.GetStream(content.Headers); } catch (IOException) { thrown = true; } Assert.IsTrue(thrown); }
public Picture Post() { if (!Request.Content.IsMimeMultipartContent("form-data")) { throw new HttpResponseException( new HttpResponseMessage(HttpStatusCode.UnsupportedMediaType) ); } var streamProvider = new MultipartMemoryStreamProvider(); var bodyparts = Request.Content.ReadAsMultipartAsync(streamProvider).Result; IDictionary<string, string> bodyPartFileNames = streamProvider.BodyPartFileNames; var data = streamProvider.FilesBytes.FirstOrDefault(); var fileName = bodyPartFileNames.Select(kv => kv.Value).FirstOrDefault(); string nameField; string descriptionField; string tagField; if (!bodyparts.TryGetFormFieldValue("name", out nameField)) { nameField = fileName; } bodyparts.TryGetFormFieldValue("description", out descriptionField); bodyparts.TryGetFormFieldValue("tags", out tagField); Picture picture = null; var image = streamProvider.FilesBytes.FirstOrDefault(); if (image != null) { picture = this.pictureRepository.Save(new Picture() { Name = nameField, Description = descriptionField, Tags = tagField }, image.ToArray()); if (!string.IsNullOrEmpty(picture.Tags)) { foreach (var tag in picture.Tags.Split(',')) { this.tagRepository.IncrementPictureCount(tag); } } } return picture; }
public void ShouldHaveParameterLessConstructor() { var provider = new MultipartMemoryStreamProvider(); Assert.IsInstanceOfType(provider, typeof(MultipartMemoryStreamProvider)); }
public void ShouldThrowOnNullHeaders() { var provider = new MultipartMemoryStreamProvider(); bool thrown = false; try { provider.GetStream(null); } catch (ArgumentNullException) { thrown = true; } Assert.IsTrue(thrown); }