public Kerkese(MultipartFormDataStreamProvider formData) { string dokumentName = null; MultipartFileData file = null; if (formData.FileData.Count > 0) { file = formData.FileData.First(); dokumentName = file.Headers.ContentDisposition.FileName; dokumentName = dokumentName.Trim('"'); } // remove " from name var data = formData.FormData; Id = Int32.Parse(data.GetValues("Id").First()); Titulli = data.GetValues("Titulli").First(); StatusId = Int32.Parse(data.GetValues("StatusId").First()); Pershkrimi = data.GetValues("Pershkrimi").First(); if (Pershkrimi == "") { Pershkrimi = null; } DataRegjistrimit = DateTime.Now; EmriDokumentit = dokumentName; var d = data.GetValues("DataKerkeses").First(); DataKerkeses = DateTime.Parse(d); var p = data.GetValues("DataPerfundimit").First(); DataPerfundimit = Convert.ToDateTime(p); }
public async Task <object> PostUploadImage() { //Check if request is MimeMultipart if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } string root = HttpContext.Current.Server.MapPath("~/App_Data"); var provider = new MultipartFormDataStreamProvider(root); //Read Form data var result = await Request.Content.ReadAsMultipartAsync(provider); var values = provider.FormData.GetValues(provider.FormData.AllKeys[0])[0]; //convert stream to EmployeeDto Object var employeeData = JsonConvert.DeserializeObject <EmployeeDto>(values); var httpRequest = HttpContext.Current.Request; var image = httpRequest.Files[0]; if (image != null) { Employee newEmployee = new Employee(); newEmployee.firstname = employeeData.firstname; newEmployee.lastname = employeeData.lastname; newEmployee.salary = Decimal.Parse(employeeData.salary); newEmployee.hiredate = DateTime.Parse(employeeData.hiredate); newEmployee.picturetype = image.ContentType; newEmployee.picturefilename = Path.GetFileName(image.FileName); newEmployee.picturefile = new byte[image.ContentLength]; image.InputStream.Read(newEmployee.picturefile, 0, image.ContentLength); db.Employees.Add(newEmployee); db.SaveChanges(); } return(Ok()); }
public async Task <HttpResponseMessage> PostSurveys() { var idService = HttpContext.Current.Request.Form["idService"]; BsonArray filesNames = MongoConnection.Instance.getServicio(Convert.ToInt32(idService)).fotos; string uploadFolder = HttpContext.Current.Server.MapPath("~/App_Data"); MultipartFormDataStreamProvider streamProvider = new MultipartFormDataStreamProvider(uploadFolder); MultipartFileStreamProvider multipartFileStreamProvider = await Request.Content.ReadAsMultipartAsync(streamProvider); string StoragePath = "~/Images/" + idService + "/"; String filePath = HostingEnvironment.MapPath(StoragePath); foreach (MultipartFileData fileData in streamProvider.FileData) { if (string.IsNullOrEmpty(fileData.Headers.ContentDisposition.FileName)) { return(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted")); } string fileName = fileData.Headers.ContentDisposition.FileName; if (fileName.StartsWith("\"") && fileName.EndsWith("\"")) { fileName = fileName.Trim('"'); } if (fileName.Contains(@"/") || fileName.Contains(@"\")) { fileName = Path.GetFileName(fileName); } if (fileName != "") { var tmp_name = Convert.ToString((DateTime.UtcNow.Subtract(new DateTime(2017, 1, 1))).TotalSeconds); tmp_name = tmp_name.Trim('.'); fileName = tmp_name + "_" + fileName; filesNames.Add(fileName); File.Move(fileData.LocalFileName, Path.Combine(filePath, fileName)); } } MongoConnection.Instance.addPhotos(filesNames, idService); return(Request.CreateResponse(HttpStatusCode.OK)); }
public async Task <KerkesResponse> KrijoKerkesen() { var provider = new MultipartFormDataStreamProvider(TempPath); await Request.Content.ReadAsMultipartAsync(provider); var kerkesRequest = new KrijoKerkesRequest(provider); kerkesRequest.Valido(); if (kerkesRequest.Errors.Count() > 0) { DeleteTempFile(provider); return(new KerkesResponse { MeSukses = false, Errors = kerkesRequest.Errors }); } var kerkesa = kerkesRequest.MerrKerkesen(); var result = await KerkesMenaxher.KrijoKerkeseAsync(kerkesa); if (!result.IsSuccess) { DeleteTempFile(provider); return(new KerkesResponse(result)); } SaveFile(provider, kerkesa); return(new KerkesResponse { MeSukses = result.IsSuccess }); }
public async Task <HttpResponseMessage> PostFormData() { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } string root = HttpContext.Current.Server.MapPath("~/midia"); var provider = new MultipartFormDataStreamProvider(root); try { //VERIFICA SE EXISTE A PASTA, SE PODE SALVAR E SALVA UMA COPIA DOS ARQUIVOS await Request.Content.ReadAsMultipartAsync(provider); //VARIAVEL QUE PASSAMOS NO POST var variavel = provider.FormData[0].ToString(); foreach (MultipartFileData file in provider.FileData) { var fileName = file.Headers.ContentDisposition.FileName.ToString().Replace("\"", ""); var extensao = System.IO.Path.GetExtension(fileName); // DELETAR O ARQUIVO ANTES DE CRIAR try { System.IO.File.Delete(root + @"\" + variavel + extensao); } catch { /* NÃO EXISTIA O ARQUIVO AINDA */ } System.IO.File.Copy(file.LocalFileName, root + @"\" + variavel + extensao); System.IO.File.Delete(file.LocalFileName); } return(Request.CreateResponse(HttpStatusCode.OK)); } catch (System.Exception e) { return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e)); } }
public async Task <string> Post() { string message = null; var ctx = HttpContext.Current; var root = ctx.Server.MapPath("~/App_Data"); var provider = new MultipartFormDataStreamProvider(root); try { await Request.Content.ReadAsMultipartAsync(provider); foreach (var file in provider.FileData) { var name = file.Headers .ContentDisposition .FileName; name = name.Trim('"'); var localFileName = file.LocalFileName; var filePath = System.IO.Path.Combine(root, name); File.Move(localFileName, filePath); pathFile.path = filePath; message = jsString.returnData(pathFile); } } catch (Exception ex) { return(ex.Message.ToString()); } return(message); }
public async Task <HttpResponseMessage> FileUpload() { string root = HttpContext.Current.Server.MapPath("~/App_Data"); var provider = new MultipartFormDataStreamProvider(root); try { // Read the form data. await Request.Content.ReadAsMultipartAsync(provider); // This illustrates how to get the file names. foreach (MultipartFileData file in provider.FileData) { Trace.WriteLine(file.Headers.ContentDisposition.FileName); Trace.WriteLine("Server file path: " + file.LocalFileName); } return(Request.CreateResponse(HttpStatusCode.OK)); } catch (Exception e) { return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e)); } }
/// <summary> /// The preceding example matches a scenario in which the client application uses an HTML form to submit a file /// to the ASP.NET Web API service.When you use form submit to upload files, the browser uploads the content using a /// special multipart/form-data MIME type /// </summary> /// <returns></returns> public async Task <HttpResponseMessage> Post() { // Check if the request contains multipart/form-data. if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(Request.CreateErrorResponse( HttpStatusCode.UnsupportedMediaType, "Request does not contain a photo")); } string root = HttpContext.Current.Server.MapPath("~/images"); var provider = new MultipartFormDataStreamProvider(root); // Read the file - this will also save the file await Request.Content.ReadAsMultipartAsync(provider); // Change the file name from a temp name to the original name string fileName = provider.FileData[0].Headers.ContentDisposition.FileName.Replace("\"", ""); string tempPath = provider.FileData[0].LocalFileName; string newPath = Path.Combine(Path.GetDirectoryName(tempPath), fileName); File.Move(tempPath, newPath); var response = Request.CreateResponse(HttpStatusCode.Accepted); return(response); }
// POST api/files public Task <HttpResponseMessage> Post() { var request = this.Request; if (!request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var provider = new MultipartFormDataStreamProvider(WebApiApplication.UploadDir); var task = request.Content.ReadAsMultipartAsync(provider). ContinueWith <HttpResponseMessage>(_ => { return(new HttpResponseMessage { Content = new StringContent("File uploaded.") }); } ); // Create/insert SQL row here return(task); }
/// <summary> /// The Upload File To Server function. /// </summary> /// <returns> /// The <see cref="Task"/>. /// </returns> /// <exception cref="HttpResponseException"> /// Something something. /// </exception> public async Task <HttpResponseMessage> UploadFileToServer() { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var root = System.Web.HttpContext.Current.Server.MapPath("~/App_Data/Temp/FileUploads"); Directory.CreateDirectory(root); var provider = new MultipartFormDataStreamProvider(root); var result = await Request.Content.ReadAsMultipartAsync(provider); var fileName = string.Empty; // get the files foreach (var file in result.FileData) { fileName += "," + file.LocalFileName; } return(Request.CreateResponse(HttpStatusCode.OK, fileName)); }
private static List <string> MoveFilesToTransactionFolder(MultipartFormDataStreamProvider provider, string transactionId) { var filePaths = new List <string>(); foreach (var file in provider.FileData) { var correctFileName = file.Headers.ContentDisposition.FileName; correctFileName = correctFileName.StripIllegalFilePathCharacters(); var tmpFolderPath = Path.GetDirectoryName(file.LocalFileName); var fileInfo = new FileInfo(file.LocalFileName); if (!Directory.Exists(Path.Combine(tmpFolderPath, transactionId))) { Directory.CreateDirectory(Path.Combine(tmpFolderPath, transactionId)); } fileInfo.MoveTo(Path.Combine(tmpFolderPath, transactionId, correctFileName)); filePaths.Add(Path.Combine(tmpFolderPath, transactionId, correctFileName)); } return(filePaths); }
public async Task SetFileData() { multipartFormDataStreamProvider = await Request.Content.ReadAsMultipartAsync(streamProvider); //設定檔案資訊 foreach (var fileData in multipartFormDataStreamProvider.FileData) { var datas = new Infrastructure.Entity.FileStorage() { Name = fileData.Headers.ContentDisposition.FileName.Trim('\"'), FileContentType = fileData.Headers.ContentType.MediaType, FileGuid = Guid.NewGuid(), }; //建立實體檔案 File.Copy(fileData.LocalFileName, Path.Combine(drivePath, datas.FileGuid.ToString("N"))); File.Delete(fileData.LocalFileName); var physicalFiles = File.OpenRead(Path.Combine(drivePath, datas.FileGuid.ToString("N"))); datas.FileSize = Convert.ToInt32(physicalFiles.Length); multipartFormDataFiles.Add(datas); fileStreams.Add(physicalFiles); fileStreamIndex++; } }
public async Task <bool> Upload() { try { var fileuploadPath = ConfigurationManager.AppSettings["FileUploadLocation"]; var provider = new MultipartFormDataStreamProvider(fileuploadPath); var content = new StreamContent(HttpContext.Current.Request.GetBufferlessInputStream(true)); foreach (var header in Request.Content.Headers) { content.Headers.TryAddWithoutValidation(header.Key, header.Value); } await content.ReadAsMultipartAsync(provider); return(true); } catch (Exception) { // todo: add in exeption logging nlog/log4net or something more advanced return(false); } }
private void InitEnvironment() { storageAccount = CloudStorageAccount.Parse( CloudConfigurationManager.GetSetting("StorageConnectionString")); queueClient = storageAccount.CreateCloudQueueClient(); queue = queueClient.GetQueueReference(CloudConfigurationManager.GetSetting("PhotoQueueName")); queue.CreateIfNotExists(); blobClient = storageAccount.CreateCloudBlobClient(); container = blobClient.GetContainerReference(CloudConfigurationManager.GetSetting("TempBlobContainerNamePhoto")); // Check if the request contains multipart/form-data. if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } string root = HttpContext.Current.Server.MapPath("~/App_Data"); provider = new MultipartFormDataStreamProvider(root); blobPrefixString = CloudConfigurationManager.GetSetting("TempBlobRelativeLocationPhoto"); }
public async Task <List <FileUploadModel> > UploadBlobs(HttpContent httpContent) { var MultiPartProvider = new MultipartFormDataStreamProvider(Path.GetTempPath()); await httpContent.ReadAsMultipartAsync(MultiPartProvider).ContinueWith(task => { if (task.IsFaulted || task.IsCanceled) { throw task.Exception; } }); var blobContainer = BlobHelper.GetBlobContainer(); List <FileUploadModel> Uploads = new List <FileUploadModel>(); foreach (var fileData in MultiPartProvider.FileData) { FileUploadModel fileUpload = await UploadOneToBlob(blobContainer, fileData); Uploads.Add(fileUpload); } return(Uploads); }
public async Task <IHttpActionResult> CreateGarage() { ResponseDataDTO <int> response = new ResponseDataDTO <int>(); try { var path = Path.GetTempPath(); MultipartFormDataStreamProvider streamProvider = new MultipartFormDataStreamProvider(path); // get data from formdata GarageViewModel GarageViewModel = new GarageViewModel { GarageID = Guid.Parse(streamProvider.FormData["GarageID"]), GarageName = Convert.ToString(streamProvider.FormData["GarageName"]), Address = Convert.ToString(streamProvider.FormData["Address"]), DateStart = Convert.ToDateTime(streamProvider.FormData["DateStart"]), DateEnd = Convert.ToDateTime(streamProvider.FormData["DateEnd"]), }; // mapping view model to entity var createdGarage = _mapper.Map <Garage>(GarageViewModel); // save new Garage _Garageservice.Create(createdGarage); // return response response.Code = HttpCode.OK; response.Message = MessageResponse.SUCCESS; response.Data = 1; return(Ok(response)); } catch (Exception ex) { response.Code = HttpCode.INTERNAL_SERVER_ERROR; response.Message = MessageResponse.FAIL; response.Data = 0; Console.WriteLine(ex.ToString()); return(Ok(response)); } }
public async Task <IHttpActionResult> EditUser() { HttpPostedFile userPhoto = null; if (HttpContext.Current.Request.Files.Count > 0) { userPhoto = HttpContext.Current.Request.Files[0]; } string appData = HttpContext.Current.Server.MapPath("~/App_Data"); MultipartFormDataStreamProvider provider = new MultipartFormDataStreamProvider(appData); provider = await Request.Content.ReadAsMultipartAsync(provider); if (userPhoto != null) { if (appUserService.EditUser(userPhoto.InputStream, provider) > 0) { return(Ok()); } else { return(InternalServerError()); } } else { if (appUserService.EditUser(provider) > 0) { return(Ok()); } else { return(InternalServerError()); } } }
public async Task <Tuple <bool, string> > SaveImages() { Tuple <bool, string> resTuple = null; try { System.Web.HttpFileCollection hfc = System.Web.HttpContext.Current.Request.Files; if (!Directory.Exists(fileUploadPath)) { Directory.CreateDirectory(fileUploadPath); } else { Array.ForEach(Directory.GetFiles(fileUploadPath), delegate(string path) { File.Delete(path); }); } var provider = new MultipartFormDataStreamProvider(fileUploadPath); var result = await Request.Content.ReadAsMultipartAsync(provider); if (result.FormData == null) { return(Tuple.Create(false, "BadRequest")); } resTuple = await _repo.SaveImages(result, hfc, fileUploadPath); } catch (Exception ex) { ErrorLog.Write(ex); } return(resTuple); }
public Task <HttpResponseMessage> UploadImagePost() { HttpRequestMessage request = this.Request; if (!request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.UnsupportedMediaType)); } string root = System.Web.HttpContext.Current.Server.MapPath("~/App_Data/Uploads"); var provider = new MultipartFormDataStreamProvider(root); var task = request.Content.ReadAsMultipartAsync(provider). ContinueWith <HttpResponseMessage>(o => { // Show all the key-value pairs. NameValueCollection nvc = HttpContext.Current.Request.Form; foreach (string kvp in nvc.AllKeys) { Console.WriteLine(kvp); } FileInfo finfo = new FileInfo(provider.FileData.First().LocalFileName); string guid = Guid.NewGuid().ToString(); File.Move(finfo.FullName, Path.Combine(root, guid + "_" + provider.FileData.First().Headers.ContentDisposition.FileName.Replace("\"", ""))); return(new HttpResponseMessage() { Content = new StringContent("File uploaded.") }); } ); return(task); }
// Extracts Request FormatData as a strongly typed model private Record GetFormData(MultipartFormDataStreamProvider result) { Record rec = new Record(); var keys = result.FormData.Keys; foreach (var k in keys) { if (k.ToString().ToLower().IndexOf("tradingdate") > 0) { rec.TradingDate = int.Parse(result.FormData.GetValues(k.ToString()).FirstOrDefault().ToString()); } if (k.ToString().ToLower().IndexOf("title") > 0) { rec.Title = result.FormData.GetValues(k.ToString()).FirstOrDefault().ToString(); } if (k.ToString().ToLower().IndexOf("type") > 0) { rec.Type = result.FormData.GetValues(k.ToString()).FirstOrDefault().ToString(); } if (k.ToString().ToLower().IndexOf("zoneid") > 0) { var zoneIDString = result.FormData.GetValues(k.ToString()).FirstOrDefault().ToString(); if (!zoneIDString.Equals("null", StringComparison.CurrentCultureIgnoreCase)) { rec.ZoneId = int.Parse(zoneIDString); } } } return(rec); }
public async Task <HttpResponseMessage> PostFormData() { logger.Info("Got Post Data " + Request.Content.IsMimeMultipartContent()); // Check if the request contains multipart/form-data. if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var provider = new MultipartFormDataStreamProvider(FILE_TEMP_PATH); try { // Read the form data. await Request.Content.ReadAsMultipartAsync(provider); // This illustrates how to get the file names. //foreach (MultipartFileData file in provider.FileData) //{ // logger.Debug(file.Headers.ContentDisposition.FileName); // logger.Debug("Server file path: " + file.LocalFileName); //} var file = provider.FileData.First(); return(Request.CreateResponse(HttpStatusCode.OK, new { ext = Path.GetExtension(file.Headers.ContentDisposition.FileName.Replace("\"", "")), fileName = Path.GetFileName(file.LocalFileName) })); } catch (System.Exception e) { return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e)); } }
public Task <HttpResponseMessage> PostFormData() { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } string path = HttpContext.Current.Server.MapPath("~/App_Data"); var provider = new MultipartFormDataStreamProvider(path); var task = Request.Content.ReadAsMultipartAsync(provider).ContinueWith <HttpResponseMessage>(t => { if (t.IsFaulted || t.IsCanceled) { Request.CreateErrorResponse(HttpStatusCode.InternalServerError, t.Exception); } string filePath = provider.FileData.First().LocalFileName; string result = TextProcessor.EditText(filePath, out bool success); System.IO.File.Delete(filePath); if (success) { var response = new HttpResponseMessage(HttpStatusCode.OK); response.Content = new StringContent(result, System.Text.Encoding.UTF8, "text/plain"); return(response); } else { var response = new HttpResponseMessage(HttpStatusCode.BadRequest); response.Content = new StringContent(result, System.Text.Encoding.UTF8, "text/plain"); return(response); } }); return(task); }
public async Task UploadSingleFile() { if (!Request.Content.IsMimeMultipartContent()) { Request.CreateErrorResponse(HttpStatusCode.UnsupportedMediaType, new NotSupportedException("Media type not supported")); } var root = HttpContext.Current.Server.MapPath("~/Content/images"); var dataFolder = HttpContext.Current.Server.MapPath("~/Content/images"); Directory.CreateDirectory(root); var provider = new MultipartFormDataStreamProvider(root); var result = await Request.Content.ReadAsMultipartAsync(provider); string fileName = string.Empty; foreach (MultipartFileData fileData in provider.FileData) { fileName = fileData.Headers.ContentDisposition.FileName; if (fileName.StartsWith("\"") && fileName.EndsWith("\"")) { fileName = fileName.Trim('"'); } if (fileName.Contains(@"/") || fileName.Contains(@"\")) { fileName = result.FormData["model"] + "_" + Path.GetFileName(fileName); } if (File.Exists(Path.Combine(dataFolder, fileName))) { File.Delete(Path.Combine(dataFolder, fileName)); } File.Move(fileData.LocalFileName, Path.Combine(dataFolder, fileName)); File.Delete(fileData.LocalFileName); } Request.CreateResponse(HttpStatusCode.OK, new { fileName = fileName }); }
public List <FieldVisitStExcel> UploadFieldVisitData(MultipartFormDataStreamProvider provider) { List <FieldVisitStExcel> distinctStudents; var file = provider.FileData.FirstOrDefault(); if (file == null) { throw new InvalidOperationException("Server could not read uploaded excel file"); } var userFileName = file.Headers.ContentDisposition.FileName.Replace("\"", string.Empty); var student = new StudentsUploadDetails(); var colsDictionary = student.GetColumnsDictionary(); using (TextReader reader = File.OpenText(file.LocalFileName)) { var parseline = _csv.Parse(reader); var colsCount = parseline.GetUpperBound(0); var valueDictionary = colsDictionary.Keys.ToDictionary(str => str, str => Array.FindIndex(parseline[0], c => c == colsDictionary[str])); distinctStudents = student.FindRowsFromExcel(parseline, valueDictionary); } return(distinctStudents); }
public ActionResult Upload() { // Initialize Context & Path to files var ctx = this.HttpContext; var root = ctx.Server.MapPath("~/"); // Receive file & meta data var provider = new MultipartFormDataStreamProvider(root); var files = Request.Files; var input_file = files[0]; string filetype = Request.Form["type"]; var filesPath = $"{root}/Resources/userfiles/{filetype}/"; // Initialize File var FileModelType = manager.GetModelType(filetype); var FileModelObject = Activator.CreateInstance(FileModelType, input_file, Request); dynamic File = Convert.ChangeType(FileModelObject, FileModelType); // Initialize DB Context var FileContext = _context.GetContext(filetype); // Save File to disk & DB input_file.SaveAs($"{filesPath + File.Name + "." + File.Extension}"); FileContext.Add(File); // Save DB Changes _context.SaveChanges(); FileTypeDetails fileDetails = manager.FileQuery(filetype); FileModelFileTypeView data = new FileModelFileTypeView(File, fileDetails, true); return(View("~/Views/FileView/FileShow.cshtml", data)); }
public Task <HttpResponseMessage> Upload(string filename) { filename = filename + ".jpg"; HttpRequestMessage request = this.Request; if (!request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.UnsupportedMediaType)); } string root = System.Web.HttpContext.Current.Server.MapPath("~/Uploads"); var provider = new MultipartFormDataStreamProvider(root); var task = request.Content.ReadAsMultipartAsync(provider). ContinueWith <HttpResponseMessage>(o => { FileInfo finfo = new FileInfo(provider.FileData.First().LocalFileName); if (File.Exists(Path.Combine(root, filename))) { File.Delete(Path.Combine(root, filename)); File.Move(finfo.FullName, Path.Combine(root, filename)); } else { File.Move(finfo.FullName, Path.Combine(root, filename)); } return(new HttpResponseMessage() { Content = new StringContent("File uploaded.") }); } ); return(task); }
public async Task <ResponseHelper <string> > UploadFile(string imagenAnterior = "") { #region Variables string path = "~/Content/images/"; var ctx = HttpContext.Current; var root = ctx.Server.MapPath(path); var provider = new MultipartFormDataStreamProvider(root); string name = ""; ResponseHelper <string> rs = new ResponseHelper <string>(); #endregion //Eliminar la imagen anterior try { if (imagenAnterior != null && imagenAnterior != "" && File.Exists(root + imagenAnterior)) { File.Delete(root + imagenAnterior); } await Request.Content.ReadAsMultipartAsync(provider); foreach (var file in provider.FileData) { name = General.CrearNombreImagen(100) + DateTime.Now.ToString("yyyyMMddHHmmss") + Path.GetExtension(file.Headers.ContentDisposition.FileName.Trim('"')); File.Move(file.LocalFileName, Path.Combine(root, name)); } rs.Result = name; rs.SetResponse(true, Status.Success, HttpStatusCode.Created); } catch (Exception ex) { rs.Result = name; return(rs.SetResponse(false, Status.Error, HttpStatusCode.InternalServerError)); } return(rs); }
public static async Task <MultipartFormInfo> ReadFile(this ApiController controller) { var Request = controller.Request; if (Request.Content.IsMimeMultipartContent()) { string root = HttpContext.Current.Server.MapPath("~/App_Data"); var provider = new MultipartFormDataStreamProvider(root); await Request.Content.ReadAsMultipartAsync(provider); var form = new MultipartFormInfo(); foreach (MultipartFileData file in provider.FileData) { var fileName = file.Headers.ContentDisposition.FileName; fileName = fileName.Replace("\"", ""); var mpi = new MultipartFileInfo() { RemoteFileName = fileName, FileInfo = new FileInfo(file.LocalFileName) }; form.Files.Add(mpi); } foreach (var key in provider.FormData.AllKeys) { form.FormData[key] = provider.FormData.GetValues(key); } return(form); } return(null); }
public async Task <HttpResponseMessage> PutAttachImage(int id) { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } OfferModel offer = offerService.GetOffer(id); if (offer == null) { return(Request.CreateResponse(HttpStatusCode.NotFound)); } string root = HttpContext.Current.Server.MapPath("~/App_Data"); var provider = new MultipartFormDataStreamProvider(root); try { await Request.Content.ReadAsMultipartAsync(provider); foreach (MultipartFileData file in provider.FileData) { offerService.UpdateOfferImage(file.LocalFileName, id); } // This will probably throw an exception.... offer = offerService.GetOffer(id); return(Request.CreateResponse(offer)); } catch (Exception e) { return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e)); } }
public async Task <HttpResponseMessage> VerifyAppUser() { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } string root = HttpContext.Current.Server.MapPath("~/App_Data"); var provider = new MultipartFormDataStreamProvider(root); try { await Request.Content.ReadAsMultipartAsync(provider); string branchId = provider.FormData.GetValues("Id")[0]; int id = Int32.Parse(branchId); Branch branch = db.Branches.Get(id); MultipartFileData file = provider.FileData[0]; string destinationFilePath = HttpContext.Current.Server.MapPath("~/Content/Images/BranchImages/"); destinationFilePath += branchId + ".jpg"; if (File.Exists(destinationFilePath)) { File.Delete(destinationFilePath); } File.Copy(file.LocalFileName, destinationFilePath); File.Delete(file.LocalFileName); branch.Image = @"Content/Images/BranchImages/" + branchId + ".jpg"; db.Branches.Update(branch); db.Complete(); return(Request.CreateResponse(HttpStatusCode.OK)); } catch (System.Exception e) { return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e)); } }