public virtual async Task <HttpResponseMessage> Upload()
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
}
var tempPath = HostingEnvironment.MapPath("~/Uploads/Temp");
if (!Directory.Exists(tempPath))
{
Directory.CreateDirectory(tempPath);
}
List <string> files = new List <string>();
var provider = new CustomMultipartFormDataStreamProvider(tempPath);
return(await Request.Content.ReadAsMultipartAsync(provider)
.ContinueWith(t =>
{
if (t.IsFaulted || t.IsCanceled)
{
Request.CreateErrorResponse(HttpStatusCode.InternalServerError, t.Exception);
}
foreach (MultipartFileData file in provider.FileData)
{
files.Add(Path.GetFileName(file.LocalFileName));
}
// Send OK Response along with saved file names to the client.
return Request.CreateResponse(HttpStatusCode.OK, files);
//返回上传后的文件全路径
//return new HttpResponseMessage() { Content = new StringContent(fileName) };
}));
}
// POST api/file
// http://www.asp.net/web-api/overview/advanced/sending-html-form-data,-part-2
// http://www.intstrings.com/ramivemula/articles/file-upload-using-multipartformdatastreamprovider-in-asp-net-webapi/
// http://www.strathweb.com/2012/08/a-guide-to-asynchronous-file-uploads-in-asp-net-web-api-rtm/
// http://benfoster.io/blog/web-api-multipart-file-upload-additional-form-data
// http://jflood.net/2012/06/03/asp-net-webapi-upload-image-with-custom-mediatypeformatter/
public async Task<HttpResponseMessage> PostFormData()
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
string fileSaveLocation = HostingEnvironment.MapPath("~/_temp");
var provider = new CustomMultipartFormDataStreamProvider(fileSaveLocation);
foreach (var item in provider.Contents)
{
provider.Contents.Remove(item);
}
try
{
await Request.Content.ReadAsMultipartAsync(provider);
var files = new List<string>();
foreach (MultipartFileData file in provider.FileData)
{
files.Add(Path.GetFileName(file.LocalFileName));
}
return Request.CreateResponse(HttpStatusCode.OK, files, "application/json");
}
catch (Exception ex)
{
return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex);
}
}
public async Task <HttpResponseMessage> Upload()
{
try
{
if (Request.Content.IsMimeMultipartContent())
{
new ATTACHMENTBL().CreateDirectory(baseFolder);
var streamProvider = new CustomMultipartFormDataStreamProvider(baseFolder);
await Request.Content.ReadAsMultipartAsync(streamProvider);
var attachmentsDataModel = new List <ATTACHMENTDC>();
for (int i = 0; i < streamProvider.FormData.Count / 19; i++)
{
attachmentsDataModel.Add(AttachmentMapper.ToDataModel(streamProvider, i));
}
return(Request.CreateResponse(HttpStatusCode.OK, attachmentsDataModel));
}
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable,
"This request is not properly formatted"));
}
catch (Exception ex)
{
Logging.LogExceptionInFile(ex.Message, ex.Source, "", ex.StackTrace);
throw ex;
}
}
// POST api/file
// http://www.asp.net/web-api/overview/advanced/sending-html-form-data,-part-2
// http://www.intstrings.com/ramivemula/articles/file-upload-using-multipartformdatastreamprovider-in-asp-net-webapi/
// http://www.strathweb.com/2012/08/a-guide-to-asynchronous-file-uploads-in-asp-net-web-api-rtm/
// http://benfoster.io/blog/web-api-multipart-file-upload-additional-form-data
// http://jflood.net/2012/06/03/asp-net-webapi-upload-image-with-custom-mediatypeformatter/
public async Task <HttpResponseMessage> PostFormData()
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
string fileSaveLocation = HostingEnvironment.MapPath("~/_temp");
var provider = new CustomMultipartFormDataStreamProvider(fileSaveLocation);
foreach (var item in provider.Contents)
{
provider.Contents.Remove(item);
}
try
{
await Request.Content.ReadAsMultipartAsync(provider);
var files = new List <string>();
foreach (MultipartFileData file in provider.FileData)
{
files.Add(Path.GetFileName(file.LocalFileName));
}
return(Request.CreateResponse(HttpStatusCode.OK, files, "application/json"));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex));
}
}
public async Task <string> Post()
{
// Verify request's media type.
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var root = HttpContext.Current.Server.MapPath("~/App_Data");
// Read the form data as a multipart upload request. We created the
// CustomMultipartFormDataStreamProvider class to change the default behavior of the
// MultipartFormDataStreamProvider class, which stores the uploded file on a
// {root}/BodyPart_{Guid} path.
var provider = new CustomMultipartFormDataStreamProvider(root);
await Request.Content.ReadAsMultipartAsync(provider);
// Verify if at least one file was uploaded and get the first uploaded file.
if (provider.FileData == null || !provider.FileData.Any())
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
var file = provider.FileData.First();
// Return the path of the stored file.
return(Path.GetFileName(file.LocalFileName));
}
public async Task <HttpResponseMessage> Add()
{
try
{
var provider = new CustomMultipartFormDataStreamProvider(workingFolder);
await Task.Run(async() => await Request.Content.ReadAsMultipartAsync(provider));
var photoDto = new PhotoDto();
foreach (var file in provider.FileData)
{
var data = provider.FormData;
var fileInfo = new FileInfo(file.LocalFileName);
photoDto = new PhotoDto
{
Name = fileInfo.Name,
PhotographerId = int.Parse(data.Get("Content[PhotographerId]"))
};
photoService.Add(photoDto);
}
return(new HttpResponseMessage(HttpStatusCode.OK));
}
catch (Exception ex)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
}
public async Task <IHttpActionResult> LoadAsync(Guid claimId)
{
var serverUploadFolder = string.Format("{0}{1}\\", FileStorageProvider.GetCommonPathToScans(), claimId);
if (!Directory.Exists(serverUploadFolder))
{
Directory.CreateDirectory(serverUploadFolder);
}
var streamProvider = new CustomMultipartFormDataStreamProvider(serverUploadFolder);
await Request.Content.ReadAsMultipartAsync(streamProvider);
var scan = new Scan()
{
Id = streamProvider.ScanId, ClaimId = claimId
};
scan.CreateDate = DateTime.Now;
scan.OriginalName = streamProvider.FileData.First().Headers.ContentDisposition.FileName.Trim('"');
_context.Scans.Add(scan);
_context.SaveChanges();
return(Ok(scan.Id));
}
public async Task <IHttpActionResult> Post()
{
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
return(BadRequest("Unsupported media type"));
}
CustomMultipartFormDataStreamProvider provider = new CustomMultipartFormDataStreamProvider(_workingFolder);
//await Request.Content.ReadAsMultipartAsync(provider);
await Task.Run(async() => await Request.Content.ReadAsMultipartAsync(provider));
List <string> files = new List <string>();
foreach (MultipartFileData file in provider.FileData)
{
FileInfo fileInfo = new FileInfo(file.LocalFileName);
FileModel filem = new FileModel
{
Name = fileInfo.Name,
Contents = File.ReadAllBytes(file.LocalFileName),
Size = fileInfo.Length
};
string id = await _manager.CreateAsync(User, filem);
files.Add(id);
}
return(Created(files.First(), files));
}
public async Task <IHttpActionResult> Post()
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
return(BadRequest("media type not supported"));
}
var tempId = Guid.NewGuid();
var workingFolder = HttpContext.Current.Server.MapPath("~/Uploads/" + tempId);
Directory.CreateDirectory(workingFolder);
try
{
var provider = new CustomMultipartFormDataStreamProvider(workingFolder);
await Request.Content.ReadAsMultipartAsync(provider);
var files = provider.FileData
.Select(file => new FileInfo(file.LocalFileName))
.ToList();
return(Ok(tempId));
}
catch (Exception ex)
{
return(BadRequest(ex.GetBaseException().Message));
}
}
public async Task <IHttpActionResult> UploadImage()
{
var workingFolder = HttpContext.Current.Server.MapPath("~/images/" + DateTime.Today.ToString("ddMMyyyy"));
if (!Directory.Exists(workingFolder))
{
Directory.CreateDirectory(workingFolder);
}
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
return(BadRequest("Unsupported media type"));
}
try
{
var provider = new CustomMultipartFormDataStreamProvider(workingFolder);
await Request.Content.ReadAsMultipartAsync(provider);
var file = provider.FileData.First();
var fileInfo = new FileInfo(file.LocalFileName);
return(Ok(new { location = $"/images/{DateTime.Today.ToString("ddMMyyyy")}/{fileInfo.Name}" }));
}
catch (Exception ex)
{
return(BadRequest(ex.GetBaseException().Message));
}
}
public async Task <IHttpActionResult> Add()
{
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
return(BadRequest("Unsupported media type"));
}
try
{
var provider = new CustomMultipartFormDataStreamProvider(workingFolder);
//await Request.Content.ReadAsMultipartAsync(provider);
await Task.Run(async() => await Request.Content.ReadAsMultipartAsync(provider));
var file = provider.FileData.FirstOrDefault();
var fileInfo = new FileInfo(file.LocalFileName);
var photo = new PhotoViewModel
{
Name = fileInfo.Name,
Created = fileInfo.CreationTime,
Modified = fileInfo.LastWriteTime,
Size = fileInfo.Length / 1024
};
photo.Path = string.IsNullOrEmpty(photo.Name) ? null : @"../../../Resources/images/" + photo.Name;
return(Ok(new { Message = "Photos uploaded ok", Photo = photo }));
}
catch (Exception ex)
{
return(BadRequest(ex.GetBaseException().Message));
}
}
public async Task <HttpResponseMessage> Post()
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var uploadFolder = "~/Album/FileUploads";
var root = HttpContext.Current.Server.MapPath(uploadFolder);
Directory.CreateDirectory(root);
var provider = new CustomMultipartFormDataStreamProvider(root);
var result = await Request.Content.ReadAsMultipartAsync(provider);
var originalFileName = GetDeserializedFileName(result.FileData.First());
var uploadedFileInfo = new FileInfo(result.FileData.First().LocalFileName);
var fileUploadObj = GetFormData <UnitPhotoBase>(result);
var unitphoto = Mapper.Map <UnitPhotoAdd>(fileUploadObj);
unitphoto.PathName = "/Album/FileUploads/" + originalFileName;
m.UnitPhotoAdd(unitphoto);
var returnData = unitphoto;
return(this.Request.CreateResponse(HttpStatusCode.OK, new { returnData }));
}
public async Task PostProcessing_ProcessesFormData_WithCustomMultipartFormDataStreamProvider()
{
// Arrange
string tempPath = Path.GetTempPath();
int maxContents = 16;
string contentFormat = "Content {0}";
string formNameFormat = "FormName_{0}";
string fileNameFormat = "FileName_{0}";
MultipartFormDataContent multipartContent = new MultipartFormDataContent();
// Create half contents for form data and the other half for file data.
for (int index = 0; index < maxContents; index++)
{
string content = String.Format(contentFormat, index);
string formName = String.Format(formNameFormat, index);
if (index < maxContents / 2)
{
multipartContent.Add(new StringContent(content), formName);
}
else
{
string fileName = String.Format(fileNameFormat, index);
multipartContent.Add(new StringContent(content), formName, fileName);
}
}
CustomMultipartFormDataStreamProvider provider =
new CustomMultipartFormDataStreamProvider(tempPath);
foreach (HttpContent content in multipartContent)
{
provider.Contents.Add(content);
using (provider.GetStream(multipartContent, content.Headers)) { }
}
// Act
await provider.ExecutePostProcessingAsync();
// Assert
Assert.Equal(maxContents / 2, provider.FormData.Count);
// half contents for form data
for (int index = 0; index < maxContents / 2; index++)
{
string content = String.Format(contentFormat, index);
string formName = String.Format(formNameFormat, index);
Assert.Equal(content, provider.FormData[formName]);
}
// the other half for file data
HttpContent[] contents = multipartContent.ToArray();
for (int index = maxContents / 2; index < maxContents; index++)
{
int fileDataIndex = index - (maxContents / 2);
string fileName = String.Format(fileNameFormat, index);
Assert.Equal(fileName, provider.FileData[fileDataIndex].LocalFileName);
Assert.Same(contents[index].Headers, provider.FileData[fileDataIndex].Headers);
}
}
public async Task <IHttpActionResult> Upload()
{
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
if (!Directory.Exists(_uploadsPath))
{
Directory.CreateDirectory(_uploadsPath);
}
var streamProvider = new CustomMultipartFormDataStreamProvider(_uploadsPath);
await Request.Content.ReadAsMultipartAsync(streamProvider);
var file = streamProvider.FileData.FirstOrDefault();
if (file != null)
{
var descriptor = _packageService.OpenPackage(file.LocalFileName);
if (descriptor != null)
{
var retVal = descriptor.ToWebModel();
retVal.FileName = file.LocalFileName;
var dependencyErrors = _packageService.GetDependencyErrors(descriptor);
retVal.ValidationErrors.AddRange(dependencyErrors);
return(Ok(retVal));
}
}
return(NotFound());
}
public async Task <HttpResponseMessage> ReceberArquivoAsync(string nome)
{
HttpRequestMessage request = Request;
if (!request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
string root = System.Web.HttpContext.Current.Server.MapPath("~/Data/" + nome + "/"); //.Replace(':', ' ') + DateTime.Now.ToShortDateString().Replace('/', '-')
if (!Directory.Exists(root))
{
Directory.CreateDirectory(root);
}
MultipartFormDataStreamProvider provider = new CustomMultipartFormDataStreamProvider(root, 25000);
var task = request.Content.ReadAsMultipartAsync(provider);
return(await task.ContinueWith(o =>
{
if (o.IsFaulted || o.IsCanceled)
{
return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, o.Exception);
}
return new HttpResponseMessage()
{
Content = new StringContent("Arquivo recebido com sucesso!")
};
}
));
}
public Task <IEnumerable <string> > Post()
{
//throw new Exception("Custom error thrown for script error handling test!");
if (Request.Content.IsMimeMultipartContent())
{
//Simulate large file upload
System.Threading.Thread.Sleep(5000);
string fullPath = HttpContext.Current.Server.MapPath("~/Uploads");
CustomMultipartFormDataStreamProvider streamProvider = new CustomMultipartFormDataStreamProvider(fullPath);
var task = Request.Content.ReadAsMultipartAsync(streamProvider).ContinueWith(t =>
{
if (t.IsFaulted || t.IsCanceled)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
var fileInfo = streamProvider.FileData.Select(i =>
{
var info = new FileInfo(i.LocalFileName);
return("File saved as " + info.FullName + " (" + info.Length + ")");
});
return(fileInfo);
});
return(task);
}
else
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "Invalid Request!"));
}
}
// POST: papi/images
public async System.Threading.Tasks.Task <IHttpActionResult> Post()
{
try
{
var request = this.Request;
if (!request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
string root = System.Web.HttpContext.Current.Server.MapPath("~/Images");
var provider = new CustomMultipartFormDataStreamProvider(root);
await Request.Content.ReadAsMultipartAsync(provider);
string localName = provider.FileData.FirstOrDefault().LocalFileName;
localName = "/images/" + localName.Replace(root, "");
return(Ok(new { name = localName }));
}
catch (Exception ex)
{
_logger.Log(ex);
}
return(BadRequest());
}
public Task <IEnumerable <ClassifiedImageModel> > UploadImage()
{
string folderName = "images";
string PATH = HttpContext.Current.Server.MapPath("~/" + BusinessSettings.CategoryImageFolderBase);
string rootUrl = Request.RequestUri.AbsoluteUri.Replace(Request.RequestUri.AbsolutePath, String.Empty);
if (Request.Content.IsMimeMultipartContent())
{
var streamProvider = new CustomMultipartFormDataStreamProvider(PATH);
var task = Request.Content.ReadAsMultipartAsync(streamProvider).ContinueWith <IEnumerable <ClassifiedImageModel> >(t =>
{
if (t.IsFaulted || t.IsCanceled)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
var fileInfo = streamProvider.FileData.Select(i =>
{
var info = new FileInfo(i.LocalFileName);
return(new ClassifiedImageModel()
{
ImageUrl = info.Name + "sss" + rootUrl + "/" + folderName + "/" + info.Name + " sss " + info.Length / 1024
});
});
return(fileInfo);
});
return(task);
}
else
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted"));
}
}
public async Task <HttpResponseMessage> bug_form()
{
var queryId = Guid.NewGuid().ToString();
var root = HttpContext.Current.Server.MapPath("~/App_Data");
var provider = new CustomMultipartFormDataStreamProvider(root);
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
try
{
await Request.Content.ReadAsMultipartAsync(provider);
var jsonData = provider.FormData.GetValues("Jsonfile");
if (jsonData != null)
{
string json = JsonConvert.SerializeObject(jsonData).Replace(@"\", string.Empty);
System.IO.File.WriteAllText(@"C:\inetpub\wwwroot\assets\bug_form\" + queryId + ".txt", json);
}
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
return(Request.CreateResponse(HttpStatusCode.OK, '1'));
}
public async Task <FileResult> UploadMultipleFiles2()
{
//解决保存后文件名称乱码问题
var provider = new CustomMultipartFormDataStreamProvider(ServerUploadFolder);
try
{
var streamProvider = StreamConversion();
await streamProvider.ReadAsMultipartAsync(provider);
return(new FileResult
{
FileNames = provider.FileData.Select(entry => entry.LocalFileName),
Names = provider.FileData.Select(entry => entry.Headers.ContentDisposition.FileName),
Description = provider.FormData["description"],
CreatedTimestamp = DateTime.UtcNow,
UpdatedTimestamp = DateTime.UtcNow,
DownloadLink = "TODO, will implement when file is persisited"
});
}
catch (System.Exception e)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
public async Task <IHttpActionResult> UploadFilesToRecord(FileType fileType, int recordId)
{
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
try
{
if (!System.IO.Directory.Exists(HttpContext.Current.Server.MapPath("~/ProjectFiles")))
{
System.IO.Directory.CreateDirectory(HttpContext.Current.Server.MapPath("~/ProjectFiles"));
}
string root = HttpContext.Current.Server.MapPath("~/ProjectFiles");
var provider = new CustomMultipartFormDataStreamProvider(root);
// Read the form data ( and saves the files in the providers root location)
await Request.Content.ReadAsMultipartAsync(provider);
var fileNameKey = provider.FormData.AllKeys.FirstOrDefault(k => k.Equals("filename", StringComparison.OrdinalIgnoreCase));
var fileName = provider.FormData.GetValues(fileNameKey)?.FirstOrDefault();
if (string.IsNullOrWhiteSpace(fileNameKey) || string.IsNullOrWhiteSpace(fileName))
{
return(BadRequest("File Name is required."));
}
var transaction = _repoFactory.BeginTransaction();
try
{
// Get the file names.
foreach (MultipartFileData file in provider.FileData)
{
//Trace.WriteLine(file.Headers.ContentDisposition.FileName);
//Trace.WriteLine("Server file path: " + file.LocalFileName);
var savedFileName = System.IO.Path.GetFileName(file.LocalFileName);
var f = new ProjectFile
{
AssociatedRecordId = recordId,
FileTypeId = (int)fileType,
CreatedByUserId = base.UserId,
FileName = fileName,
FileLocation = $"/ProjectFiles/{savedFileName}"
};
_repoFactory.Files.CreateFile(f, transaction);
}
_repoFactory.CommitTransaction();
return(Ok());
}
catch (Exception)
{
_repoFactory.RollbackTransaction();
throw;
}
}
catch (Exception ex)
{
_logger.Error(ex, Request.RequestUri.ToString());
return(InternalServerError(ex));
}
}
public Task<IEnumerable<FileDesc>> Post()
{
var folderName = "UploadedFiles";
var PATH = HttpContext.Current.Server.MapPath("~/App_data/" + folderName);
var rootUrl = Request.RequestUri.AbsoluteUri.Replace(Request.RequestUri.AbsolutePath, String.Empty);
if (Request.Content.IsMimeMultipartContent())
{
var streamProvider = new CustomMultipartFormDataStreamProvider(PATH);
var task = Request.Content.ReadAsMultipartAsync(streamProvider).ContinueWith<IEnumerable<FileDesc>>(t =>
{
if (t.IsFaulted || t.IsCanceled)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
var fileInfo = streamProvider.FileData.Select(i =>
{
var info = new FileInfo(i.LocalFileName);
return new FileDesc(info.Name, rootUrl + "/" + folderName + "/" + info.Name, info.Length / 1024);
});
return fileInfo;
});
return task;
}
else
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted"));
}
}
public Task<HttpResponseMessage> Post()
{
var rootUrl = "c:/PrintService/Uploads/";
if (Request.Content.IsMimeMultipartContent())
{
var streamProvider = new CustomMultipartFormDataStreamProvider(rootUrl);
var task = Request.Content.ReadAsMultipartAsync(streamProvider).ContinueWith<HttpResponseMessage>(t =>
{
if (t.IsFaulted || t.IsCanceled)
throw new HttpResponseException(HttpStatusCode.InternalServerError);
t.Result.FileData.ToList().ForEach(i =>
{
var info = new FileInfo(i.LocalFileName);
Print(info.FullName);
});
return new HttpResponseMessage(HttpStatusCode.OK);
});
return task;
}
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted"));
}
/// <summary>
/// Add a photo
/// </summary>
/// <returns></returns>
public async Task <IHttpActionResult> Add()
{
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
return(BadRequest("Unsupported media type"));
}
try
{
var provider = new CustomMultipartFormDataStreamProvider(workingFolder);
await Request.Content.ReadAsMultipartAsync(provider);
var photos =
provider.FileData
.Select(file => new FileInfo(file.LocalFileName))
.Select(fileInfo => new PhotoViewModel
{
Name = fileInfo.Name,
Created = fileInfo.CreationTime,
Modified = fileInfo.LastWriteTime,
Size = fileInfo.Length / 1024
}).ToList();
return(Ok(new { Message = "Photos uploaded ok", Photos = photos }));
}
catch (Exception ex)
{
return(BadRequest(ex.GetBaseException().Message));
}
}
public Task <HttpResponseMessage> Post()
{
var rootUrl = "c:/PrintService/Uploads/";
if (Request.Content.IsMimeMultipartContent())
{
var streamProvider = new CustomMultipartFormDataStreamProvider(rootUrl);
var task = Request.Content.ReadAsMultipartAsync(streamProvider).ContinueWith <HttpResponseMessage>(t =>
{
if (t.IsFaulted || t.IsCanceled)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
t.Result.FileData.ToList().ForEach(i =>
{
var info = new FileInfo(i.LocalFileName);
Print(info.FullName);
});
return(new HttpResponseMessage(HttpStatusCode.OK));
});
return(task);
}
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted"));
}
public async Task <IHttpActionResult> Save()
{
// The implementation is based on article from: http://www.asp.net/web-api/overview/advanced/sending-html-form-data-part-2
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent())
{
Logger.Warn("Content not support for file upload");
return(this.StatusCode(HttpStatusCode.UnsupportedMediaType));
}
var rootPath = UploadDirectoryName;
var provider = new CustomMultipartFormDataStreamProvider(rootPath);
// Read the form data.
await Request.Content.ReadAsMultipartAsync(provider);
if (provider.FileData.Any())
{
Logger.Info("File(s): {0} sucessfully saved", string.Join(", ", provider.FileData.Select(fd => fd.LocalFileName)));
return(Ok());
}
else
{
Logger.Warn(Properties.Resources.NoFileSentErrorMessage);
return(BadRequest(Properties.Resources.NoFileSentErrorMessage));
}
}
public async Task <IHttpActionResult> UploadAssetToLocalFileSystem()
{
var retVal = new List <webModel.BlobInfo>();
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted"));
}
var uploadsPath = HostingEnvironment.MapPath(_uploadsUrl);
var streamProvider = new CustomMultipartFormDataStreamProvider(uploadsPath);
await Request.Content.ReadAsMultipartAsync(streamProvider).ContinueWith(t =>
{
if (t.IsFaulted || t.IsCanceled)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
});
foreach (var fileData in streamProvider.FileData)
{
var fileName = fileData.Headers.ContentDisposition.FileName.Replace("\"", string.Empty);
var blobInfo = new webModel.BlobInfo
{
Name = fileName,
Url = VirtualPathUtility.ToAbsolute(_uploadsUrl + fileName),
MimeType = MimeTypeResolver.ResolveContentType(fileName)
};
retVal.Add(blobInfo);
}
return(Ok(retVal.ToArray()));
}
public async Task <HttpResponseMessage> PostBlog()
{
{
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Unsupported media type"));
}
try
{
var provider = new CustomMultipartFormDataStreamProvider(workingFolder);
//await Request.Content.ReadAsMultipartAsync(provider);
await Task.Run(async() => await Request.Content.ReadAsMultipartAsync(provider));
// var photos = new List<PhotoViewModel>();
foreach (var file in provider.FileData)
{
var fi = new FileInfo(file.LocalFileName);
}
//foreach (var item in provider.Contents)
//{
// var atributo = item;
//}
return(Request.CreateResponse(HttpStatusCode.OK, new { message = "OK" }));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
}
public async Task <JsonResult <ApiBaseResponse> > Post()
{
var result = new ApiBaseResponse();
try
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var root = HttpContext.Current.Server.MapPath(OntextSettings.UploadImageDirectoryPath);
var provider = new CustomMultipartFormDataStreamProvider(root);
// Read the form data.
await Request.Content.ReadAsMultipartAsync(provider);
}
catch (Exception ex)
{
result.Status = ApiStatusCode.SystemError;
result.Error = ex.Message;
}
return(Json(result));
}
public Task <IEnumerable <SourceFile> > Import()
{
var folderName = "uploads";
var PATH = HttpContext.Current.Server.MapPath("~/" + folderName);
var rootUrl = Request.RequestUri.AbsoluteUri.Replace(Request.RequestUri.AbsolutePath, String.Empty);
if (Request.Content.IsMimeMultipartContent())
{
var streamProvider = new CustomMultipartFormDataStreamProvider(PATH);
var task = Request.Content.ReadAsMultipartAsync(streamProvider).ContinueWith <IEnumerable <SourceFile> >(t =>
{
if (t.IsFaulted || t.IsCanceled)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
var fileInfo = streamProvider.FileData.Select(i => {
var info = new FileInfo(i.LocalFileName);
return(new SourceFile(info.Name, rootUrl + "/" + folderName + "/" + info.Name));
});
return(fileInfo);
});
return(task);
}
else
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted"));
}
}
public async Task <HttpResponseMessage> Post()
{
string folderName = "uploads";
string PATH = HttpContext.Current.Server.MapPath("~/" + folderName);
string rootUrl = Request.RequestUri.AbsoluteUri.Replace(Request.RequestUri.AbsolutePath, String.Empty);
if (Request.Content.IsMimeMultipartContent())
{
var streamProvider = new CustomMultipartFormDataStreamProvider(PATH);
//IEnumerable<FileDesc> fileInfos = null;
await Request.Content.ReadAsMultipartAsync(streamProvider);
var fileInfo = streamProvider.FileData.Select(i =>
{
var info = new FileInfo(i.LocalFileName);
return(new FileDesc(info.Name, rootUrl + "/" + folderName + "/" + info.Name, info.Length / 1024));
});
return(Request.CreateResponse(HttpStatusCode.OK, fileInfo));
}
else
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted"));
}
}
public async Task <HttpResponseMessage> UploadFileAsync()
{
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
string root = HttpContext.Current.Server.MapPath("~/uploadedfiles");
var provider = new CustomMultipartFormDataStreamProvider(root);
List <ChatFileDTO> uploadedFiles = new List <ChatFileDTO>();
try
{
// Read the form data.
await Request.Content.ReadAsMultipartAsync(provider);
foreach (MultipartFileData file in provider.FileData)
{
string originalName = provider.GetOriginalName(file.Headers);
string serverName = Path.GetFileName(file.LocalFileName);
uploadedFiles.Add(new ChatFileDTO
{
OriginalName = originalName,
ServerPathName = serverName
});
}
return(Request.CreateResponse(HttpStatusCode.OK, uploadedFiles));
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
public async Task <IHttpActionResult> Add(int groupID)
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
return(BadRequest("Unsupported media type"));
}
var provider = new CustomMultipartFormDataStreamProvider(workingFolder);
await Request.Content.ReadAsMultipartAsync(provider);
var photos =
provider.FileData
.Select(file => new FileInfo(file.LocalFileName))
.Select(fileInfo => fileInfo.Name).ToList();
var ownerId = User.Identity.GetUserId();
var imageIds = new List <int>();
foreach (var path in photos)
{
imageIds.Add(ImageManager.AddImage(ownerId, groupID, path, DateTime.UtcNow));
}
var imageDetails = ImageManager.GetImagesForIds(User.Identity.GetUserId(), imageIds);
PiChatHub.SendGroupNewImagesNotification(groupID, imageDetails);
return(Ok(new { Message = "Photos uploaded ok" }));
}
public async Task<HttpResponseMessage> PostAttachments(string userId)
{
if (!Directory.Exists(ApplicationSettings.Instance.TicketMediaBaseUrl.ToString()))
{
Directory.CreateDirectory(ApplicationSettings.Instance.TicketMediaBaseUrl.ToString());
}
var basePath = ApplicationSettings.Instance.BaseApplicationPath;
MultipartFormDataStreamProvider provider;
var attachmentId = this.ticketService.RetrieveAttachmentSequence();
provider = new CustomMultipartFormDataStreamProvider(ApplicationSettings.Instance.TicketMediaBaseUrl.ToString(), attachmentId.ToString());
await Request.Content.ReadAsMultipartAsync(provider);
var res = new StringContent(CustomMultipartFormDataStreamProvider.FileName, System.Text.Encoding.UTF8, "text/html");
CustomMultipartFormDataStreamProvider.FileName = string.Empty;
return new HttpResponseMessage(HttpStatusCode.OK)
{
Content = res
};
}
public async Task<IHttpActionResult> AddVersao(int id)
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
return BadRequest("Tipo não suportado");
}
try
{
SynchronizationContext originalContext = SynchronizationContext.Current;
var usuario = this.sessaoDoUsuario.UsuarioAtual;
var usuarioId = usuario.Id.ToString();
var pastaTrabalho = Path.Combine(
ContextoWeb.Caminho,
"Uploads",
usuario.Id.ToString());
var provider = new CustomMultipartFormDataStreamProvider(pastaTrabalho);
if (Directory.Exists(pastaTrabalho) == false)
{
Directory.CreateDirectory(pastaTrabalho);
}
await Request.Content.ReadAsMultipartAsync(provider);
var arquivos =
provider.FileData
.Select(file => new FileInfo(file.LocalFileName))
.Select(fileInfo => new FileViewModel
{
Name = fileInfo.Name,
Created = fileInfo.CreationTime,
Modified = fileInfo.LastWriteTime,
Size = fileInfo.Length / 1024,
Path = fileInfo.FullName
}).ToList();
originalContext.Post(
delegate {
var versoes = this.versaoDocumentoRepositorio.ObterDoDocumento(id);
var versao = versoes
.OrderBy(x => x.CriadoEm)
.Last()
.Versao;
this.salvarConteudoServico.AdicionarVersao(arquivos, "[documento]" + id + "[versao]" + versao);
this.logarAcaoSistema.Execute(
TipoTrilha.Alteracao,
"Versionamento de documento",
"Nova versão do documento foi criada #" + id + " versao **" + versao);
}, null);
Request.Content.Dispose();
return Ok(new { Message = "Documentos enviados com sucesso" });
}
catch (Exception ex)
{
return BadRequest(ex.GetBaseException().Message);
}
}
// POST api/mobile
public async Task<HttpResponseMessage> Post()
{
// Check whether the POST operation is MultiPart?
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
// Prepare CustomMultipartFormDataStreamProvider in which our multipart form
// data will be loaded.
string fileSaveLocation = HCLUtility.FileUp.ApiCreatdDirectory(HttpContext.Current.Server.MapPath("/Upload/Api/"));
var provider = new CustomMultipartFormDataStreamProvider(fileSaveLocation);
List<string> files = new List<string>();
try
{
// Read all contents of multipart message into CustomMultipartFormDataStreamProvider.
await Request.Content.ReadAsMultipartAsync(provider);
foreach (MultipartFileData file in provider.FileData)
{
files.Add(Path.GetFileName(file.LocalFileName));
}
// Send OK Response along with saved file names to the client.
return Request.CreateResponse(HttpStatusCode.OK, files);
}
catch (System.Exception e)
{
return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e);
}
#region
//// 检查是否是 multipart/form-data
//if (!Request.Content.IsMimeMultipartContent("form-data"))
// throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
//HttpResponseMessage response = null;
//try
//{
// string sPath = HttpContext.Current.Server.MapPath("/Upload/");
// // 设置上传目录
// var provider = new MultipartFormDataStreamProvider(sPath);
// // 接收数据，并保存文件
// var bodyparts = await Request.Content.ReadAsMultipartAsync(provider);
// // This illustrates how to get the file names.
// foreach (MultipartFileData file in provider.FileData)
// {//接收文件
// string sjname=file.Headers.ContentDisposition.FileName;//获取上传文件实际的文件名
// string spp="Server file path: " + file.LocalFileName;//获取上传文件在服务上默认的文件名
// }//TODO:这样做直接就将文件存到了指定目录下，暂时不知道如何实现只接收文件数据流但并不保存至服务器的目录下，由开发自行指定如何存储，比如通过服务存到图片服务器
// response = Request.CreateResponse(HttpStatusCode.Accepted);
// //foreach (var file in provider.FileData)
// //{
// // FileInfo fileInfo = new FileInfo(file.LocalFileName);
// // sb.Append(string.Format("Uploaded file: {0} ({1} bytes)\n", fileInfo.Name, fileInfo.Length));
// // }
//}
//catch
//{
// throw new HttpResponseException(HttpStatusCode.BadRequest);
//}
//return response;
#endregion
}
public async Task<IHttpActionResult> Add(int id)
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
return BadRequest("Tipo não suportado");
}
try
{
SynchronizationContext originalContext = SynchronizationContext.Current;
var pastaTrabalho = Path.Combine(
ContextoWeb.Caminho,
"Uploads",
this.sessaoDoUsuario.UsuarioAtual.Id.ToString());
var provider = new CustomMultipartFormDataStreamProvider(pastaTrabalho);
if (Directory.Exists(pastaTrabalho) == false)
{
Directory.CreateDirectory(pastaTrabalho);
}
await Request.Content.ReadAsMultipartAsync(provider);
var arquivos =
provider.FileData
.Select(file => new FileViewModel
{
Name = Path.GetFileNameWithoutExtension(file.LocalFileName),
Created = DateTime.Now,
Path = file.LocalFileName,
Subject = provider.FormData["assunto"]
}).ToList();
IList<Documento> documentos = new List<Documento>();
originalContext.Post(
delegate {
documentos = this.salvarConteudoServico.Executar(arquivos);}, null);
Request.Content.Dispose();
return Ok(new { Message = "Documentos enviados com sucesso", Documentos = documentos });
}
catch (Exception ex)
{
return BadRequest(ex.GetBaseException().Message);
}
}
public async Task<IHttpActionResult> AddFoto(int id)
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
return BadRequest("Tipo não suportado");
}
try
{
SynchronizationContext originalContext = SynchronizationContext.Current;
var usuario = this.sessaoDoUsuario.UsuarioAtual;
var usuarioId = usuario.Id.ToString();
var pastaTrabalho = Path.Combine(
ContextoWeb.Caminho,
"Uploads",
usuario.Id.ToString());
var provider = new CustomMultipartFormDataStreamProvider(pastaTrabalho);
if (Directory.Exists(pastaTrabalho) == false)
{
Directory.CreateDirectory(pastaTrabalho);
}
await Request.Content.ReadAsMultipartAsync(provider);
var arquivos =
provider.FileData
.Select(file => new FileInfo(file.LocalFileName))
.Select(fileInfo => new FileViewModel
{
Name = fileInfo.Name,
Created = fileInfo.CreationTime,
Modified = fileInfo.LastWriteTime,
Size = fileInfo.Length / 1024,
Path = fileInfo.FullName
}).ToList();
originalContext.Post(
delegate {
this.salvarConteudoServico.SalvarFoto(arquivos, "[usuario]" + usuarioId);
}, null);
Request.Content.Dispose();
return Ok(new { Message = "Documentos enviados com sucesso" });
}
catch (Exception ex)
{
return BadRequest(ex.GetBaseException().Message);
}
}
public async Task<HttpResponseMessage> Post() {
if (!Request.Content.IsMimeMultipartContent()) {
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var svrpath = Path.Combine(Application.StartupPath, "UpdateFiles");
if (!Directory.Exists(svrpath)) {
Directory.CreateDirectory(svrpath);
}
var provider = new CustomMultipartFormDataStreamProvider(svrpath);
try {
await Request.Content.ReadAsMultipartAsync(provider);
// This illustrates how to get the file names.
foreach (MultipartFileData file in provider.FileData) {
FileInfo fileinfo = new FileInfo(file.LocalFileName);
var svrfilepath = Path.Combine(svrpath, provider.FormData.GetValues("ServerDir")[0], fileinfo.Name);
var svrdir= Path.Combine(svrpath, provider.FormData.GetValues("ServerDir")[0]);
if (!Directory.Exists(svrdir)) {
Directory.CreateDirectory(svrdir);
}
fileinfo.CopyTo(svrfilepath, true);
fileinfo.Delete();
Trace.WriteLine(file.Headers.ContentDisposition.FileName);
Trace.WriteLine("Server file path: " + file.LocalFileName);
}
return Request.CreateResponse(HttpStatusCode.OK);
} catch (System.Exception e) {
return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e);
}
}
public Task<IHttpActionResult> Post()
{
var basePath = ConfigurationManager.AppSettings["basePath"].ToString();
var textPath = ConfigurationManager.AppSettings["textPath"].ToString();
if (Request.Content.IsMimeMultipartContent())
{
var streamProvider = new CustomMultipartFormDataStreamProvider(basePath);
var file = Request.Content.ReadAsMultipartAsync(streamProvider).ContinueWith<IHttpActionResult>(t =>
{
if (t.IsFaulted || t.IsCanceled)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
var fileInfo = streamProvider.FileData.Select(i =>
{
var info = new FileInfo(i.LocalFileName);
string resultado = pdfToText.Convertir(basePath, info.Name);
var posiblesAnotaciones = new AnalizadorAnotaciones(this.tdDao, this.taDao).AnalizarPorPosiblesAnotaciones(resultado);
var test = textPath + @"\" + info.Name + ".txt";
var archivo = new Archivo() { Ruta = info.Name };
var guid = Guid.NewGuid();
map.Add(guid, new Archivo() { Ruta = info.Name });
string asunto = new AnalizadorAsunto().ObtenerAsunto(resultado);
if (asunto.Length > 999)
{
asunto = asunto.Substring(0, 999);
}
File.WriteAllText(test, resultado);
return new FileDesc(archivo.Id.ToString(), basePath + @"\text" + @"\" + info.Name + ".txt", info.Length / 1024, asunto, guid, posiblesAnotaciones);
});
return Ok(fileInfo);
});
return file;
}
else
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted"));
}
}
