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));
}
}
