public async Task <UploadedFileViewModel> Process(byte[] fileData, string fileName, string dataProjectId, string uploaderInitials)
{
try
{
return(await HandleSingleFile(fileData, fileName, dataProjectId, uploaderInitials));
}
catch (Exception e)
{
return(UploadedFileViewModel.Failed(fileName, e.InnermostException().Message));
}
}
public static UploadedFile ToServiceModel(this UploadedFileViewModel viewModel)
{
return(viewModel != null ? new UploadedFile
{
Id = viewModel.Id,
Name = viewModel.Name,
FileContent = viewModel.FileContent,
ContentType = viewModel.ContentType,
Lenght = viewModel.Lenght,
ReportId = viewModel.ReportId
} : null);
}
private async Task <List <UploadedFileViewModel> > UploadFilesAsync(string root)
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var provider = new MultipartFormDataStreamProvider(root);
var count = HttpContext.Current.Request.Files.Count;
var files = new List <HttpPostedFile>(count);
for (var i = 0; i < count; i++)
{
files.Add(HttpContext.Current.Request.Files[i]);
}
await Request.Content.ReadAsMultipartAsync(provider);
var list = new List <UploadedFileViewModel>();
var now = DateTime.Now;
foreach (var file in provider.FileData)
{
var temp = file.Headers.ContentDisposition.FileName;
var length = temp.Length;
var lastSlashIndex = temp.LastIndexOf(@"\", StringComparison.Ordinal);
var fileName = temp.Substring(lastSlashIndex + 2, length - lastSlashIndex - 3);
var fileInfo = files.SingleOrDefault(x => x.FileName == fileName);
long size = 0;
if (fileInfo != null)
{
size = fileInfo.ContentLength;
}
var newFile = new UploadedFileViewModel
{
FileName = fileName,
Path = file.LocalFileName,
Size = size,
Deleted = false
};
var userName = string.IsNullOrEmpty(User.Identity?.Name)
? "anonymous"
: User.Identity.Name;
newFile.CreateUser = newFile.UpdateUser = userName;
newFile.CreateTime = newFile.UpdateTime = now;
newFile.LastAction = "上传";
list.Add(newFile);
}
return(list);
}
public async Task SaveFile(UploadedFileViewModel fileViewModel, Stream contentStream, string pathToSave, string baseUrl)
{
//TODO: validate
var entity = Mapper.Map <UploadedFile>(fileViewModel);
var extension = Path.GetExtension(entity.OriginalName);
entity.FileName = $"{fileViewModel.Id}{extension}";
entity.Size = contentStream.Length;
entity.FtpFileUrl = $"{baseUrl}/uploads/{entity.FileName}";
await _fileRepository.Add(entity);
await _fileRepository.SaveChanges();
await _fileRepository.SaveFile(entity, contentStream);
}
public async Task <IActionResult> Index(IFormFile file, int?minWidth, int?minHeight, bool prependDate = false)
{
UploadedFileViewModel result = null;
if (file != null && file.Length > 0 && file.FileName != null)
{
//using (var imageStreamForDimensions = file.OpenReadStream())
//{
// var image = new Image(imageStreamForDimensions);
// if ((minWidth != null && image.Width < minWidth) || (minHeight != null && image.Height < minHeight))
// {
// return new BadRequestResult();
// }
//}
string fileName = file.FileName;
// string thumbFileName = "thumbnail_" + file.FileName;
if (prependDate)
{
fileName = DateTime.UtcNow.ToString("yyyyMMdd_hh_mm_ss_") + fileName;
// thumbFileName = DateTime.UtcNow.ToString("yyyyMMdd_hh_mm_ss_") + "thumbnail_" + fileName;
}
string uploadedFile;
using (var imageStream = file.OpenReadStream())
{
uploadedFile = await _imageRepo.UploadFileAsBlob(imageStream, fileName);
}
//string uploadedThumbnail;
//using (var thumbStream = file.OpenReadStream())
//{
// var thumbNailImage = imageService.GenerateThumbnail(thumbStream);
// uploadedThumbnail = await _imageRepo.UploadFileAsBlob(thumbNailImage, thumbFileName);
//}
result = new UploadedFileViewModel
{
FilePath = uploadedFile,
// ThumbnailPath = uploadedThumbnail
};
}
return(Ok(result));
}
public static IReadOnlyCollection <UploadedFileViewModel> ToViewModel(this IReadOnlyCollection <UploadedFile> entities)
{
if (entities.Count == 0)
{
return(Array.Empty <UploadedFileViewModel>());
}
var files = new UploadedFileViewModel[entities.Count];
var index = 0;
foreach (var entity in entities)
{
files[index] = entity.ToViewModel();
++index;
}
return(new ReadOnlyCollection <UploadedFileViewModel>(files));
}
private async Task <UploadedFileViewModel> HandleSingleFile(
byte[] fileData,
string fileName,
string dataProjectId,
string uploaderInitials)
{
var extension = Path.GetExtension(fileName)?.ToLowerInvariant();
if (extension == null)
{
throw new Exception("File has no extension");
}
var matchingFileHandlers = fileHandlers.ContainsKey(extension)
? fileHandlers[extension]
: new List <IFileHandler>();
var dataBlob = DataBlobBuilder.FromByteArray(fileData, fileName);
FileHandlingStatus fileStatus;
if (await dataBlobDatabase.ExistsAsync(dataBlob.Id))
{
fileStatus = FileHandlingStatus.AlreadyExists;
}
else
{
await dataBlobDatabase.StoreAsync(dataBlob);
fileStatus = FileHandlingStatus.Success;
}
Dictionary <string, object> additionalInformation = null;
if (matchingFileHandlers.Any(x => x.RequiresAdditionalInformation))
{
var additionalInformationRequiringFileHandlers = matchingFileHandlers.Where(x => x.RequiresAdditionalInformation).ToList();
var requestResult = await RequestAdditionalInformation(additionalInformationRequiringFileHandlers, fileName);
if (!requestResult.IsRequestCompleted)
{
return(UploadedFileViewModel.Failed(fileName, "Not enough information provided"));
}
additionalInformation = requestResult.AdditionalInformationObjects;
}
var rawDataReference = DataReference.FromIId(dataBlob);
var fileViewModels = new List <IDerivedFileDataViewModel>();
var derivedDataReferences = new List <DataReference>();
foreach (var matchingFileHandler in matchingFileHandlers)
{
var fileHandlerType = matchingFileHandler.GetType().Name;
var fileHandlerAdditionalInformation = additionalInformation.ContainsKey(fileHandlerType)
? additionalInformation[fileHandlerType]
: null;
var fileHandlerResult = await matchingFileHandler.Handle(fileData, fileName, dataProjectId, fileHandlerAdditionalInformation);
fileViewModels.AddRange(fileHandlerResult.ViewModels);
derivedDataReferences.AddRange(fileHandlerResult.DerivedDataReferences);
}
var uploadInfo = new DataProjectUploadInfo(
uploaderInitials,
DateTime.UtcNow,
dataProjectId,
rawDataReference,
derivedDataReferences,
fileName);
await dataProjectUploadInfoDatabase.StoreAsync(uploadInfo);
return(new UploadedFileViewModel(
fileName,
fileStatus,
string.Empty,
uploadInfo.Id,
rawDataReference,
derivedDataReferences,
dataApiClient,
fileViewModels,
clipboard));
}
public async Task MoveFile(UploadedFileViewModel file, string pathToMove)
{
var entity = Mapper.Map <UploadedFile>(file);
await _fileRepository.MoveFile(entity, pathToMove);
}
public IActionResult PostInline(string subPath, [FromForm] UploadedFileViewModel uploadedFile)
{
var uploadPath = _fileUtility.SaveFile(uploadedFile.File.OpenReadStream(), subPath, uploadedFile.File.FileName);
return(Ok("/" + uploadPath.Replace("\\", "/")));
}
