public async Task <VideoFileModel> UploadFile(FileUploadDTO fileUpload)
{
try
{
var uniqueDirectory = Guid.NewGuid().ToString();
_fileManagerService.CreateVideoDirectory(uniqueDirectory);
var fileLocation = Path.Combine(uniqueDirectory, fileUpload.UploadedFile.FileName);
var filePath = await _fileManagerService.SaveTempFile(fileUpload.UploadedFile, fileLocation);
var mediaInfo = await _ffmpeg.GetMediaInfo(filePath);
var videoFile = _mapper.Map <VideoFile>(mediaInfo);
videoFile.Filename = fileUpload.UploadedFile.FileName;
videoFile.FileDirectory = uniqueDirectory;
await _dbContext.Videos.AddAsync(videoFile);
await _dbContext.SaveChangesAsync();
return(_mapper.Map <VideoFileModel>(videoFile));
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
throw new Exception("Internal server error");
}
}
public async Task <IActionResult> UpdateFileUpload(int id, [FromBody] FileUploadDTO fileUploadDTO)
{
var fileUpload = fileUploadDTO.ToEntity();
await _fileUploadService.UpdateFileUpload(fileUpload);
return(Ok(fileUpload));
}
public async Task <IActionResult> CreateFileUpload(FileUploadDTO fileUploadDTO)
{
var fileUpload = fileUploadDTO.ToEntity();
await _fileUploadService.CreateFileUpload(fileUpload);
return(Ok(fileUpload));
}
// PUT api/avatar/username
public void Put(string id, [ModelBinder(typeof(FileUploadDTOModelBinder))] FileUploadDTO dto)
{
var user = UserManager.FindById(id);
user.Avatar = dto.Contents;
user.AvatarContentType = dto.ContentType;
UserManager.Update(user);
}
public async Task <IActionResult> GetFileUploadById(int id)
{
var fileUpload = await _fileUploadService.GetFileUploadById(id);
var result = FileUploadDTO.FromEntity(fileUpload);
return(Ok(result));
}
public async Task <bool> ProcessFileAsync(FileUploadDTO fileUploadDto)
{
var uploadResult = false;
await TryCatchExtension.ExecuteAndHandleErrorAsync(
async() =>
{
void PrepareDirectory(string folderPath)
{
if (!Directory.Exists(folderPath))
{
Directory.CreateDirectory(folderPath);
}
}
FileInfo WriteFileToDirectory()
{
var filePath = Path.Combine(FilesToProcessFolderPath, fileUploadDto.FileName);
File.WriteAllBytes(filePath, fileUploadDto.FileBytes);
return(new FileInfo(filePath));
}
PrepareDirectory(FilesToProcessFolderPath);
var processingFileInfo = WriteFileToDirectory();
var fileParsedResult = await _airFileParser.ParseUploadedFileAsync(processingFileInfo.FullName);
if (fileParsedResult.IsSuccess)
{
await _flightActionManagementRepository.FileContentRepository.InsertAsync(fileParsedResult.Value);
await _flightActionManagementRepository.UploadedFilesRepository.InsertAsync(new UploadedFiles {
FullPath = processingFileInfo.FullName
});
PrepareDirectory(ProcessedFolderPath);
processingFileInfo.MoveTo(Path.Combine(ProcessedFolderPath, fileUploadDto.FileName));
uploadResult = true;
}
else
{
_proLogger.Error($"An error occurred while uploading and processing the file. Error: {fileParsedResult.Error}");
}
},
ex =>
{
_proLogger.Error($"An error occurred while uploading and processing the file. Error: {ex.Message}");
uploadResult = false;
return(false);
});
return(uploadResult);
}
public async Task <ActionResult <VideoFileModel> > Upload([FromForm] FileUploadDTO fileUploadDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid data model"));
}
var result = await _videoConverterService.UploadFile(fileUploadDTO);
return(Ok(result));
}
public WebApiResult <CardAttachmentListItem> Post(int cardId, [ModelBinder(typeof(FileUploadDTOModelBinder))] FileUploadDTO dto)
{
var result = _repository.ExecuteCommand(new AddCardAttachmentCommand
{
CardId = cardId,
ContentType = dto.ContentType,
FileContent = dto.Contents,
FileName = dto.FileName.Length > 49 ? dto.FileName.Substring(0, 46) + dto.FileExtension : dto.FileName,
FileExtension = dto.FileExtension
});
return(AutoMapper.Mapper.Map <CommandResult <CardAttachment>, WebApiResult <CardAttachmentListItem> >(result));
}
private void UploadFile()
{
string uploadUrl = $"{SystemParams.API_URL}/FileHistory/UploadFile";
FileUploadDTO fileUpload = new FileUploadDTO
{
FileId = _fileInfo.Id,
FileName = _fileInfo.FileName,
ModifierUser = GetModifier(),
Version = rdUpdateNextVersion.Checked ? txtNextVersion.Text : _fileInfo.Version,
FileData = File.ReadAllBytes(_fileInfo.FilePath)
};
string json = JsonConvert.SerializeObject(fileUpload);
StringContent data = new StringContent(json, Encoding.UTF8, "application/json");
EcmHttpClient client = new EcmHttpClient(epLiteId: _fileInfo.Owner);
HttpResponseMessage response = client.PostAsync(uploadUrl, data).Result;
_fileInfo.IsUploaded = response.IsSuccessStatusCode;
}
public bool BindModel(System.Web.Http.Controllers.HttpActionContext actionContext, ModelBindingContext bindingContext)
{
var request = actionContext.Request;
if (request.Content.IsMimeMultipartContent())
{
InMemoryMultipartFormDataStreamProvider streamProvider = new InMemoryMultipartFormDataStreamProvider();
FileUploadDTO dto = new FileUploadDTO();
var task = Task.Run(async() => {
await request.Content.ReadAsMultipartAsync(streamProvider).ContinueWith(t =>
{
if (t.IsFaulted || t.IsCanceled)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
foreach (var i in streamProvider.Files)
{
dto.FileName = Path.GetFileName(i.Headers.ContentDisposition.FileName.Replace("\"", String.Empty));
dto.FileExtension = Path.GetExtension(dto.FileName);
if (String.IsNullOrEmpty(dto.Title))
{
dto.Title = Path.GetFileNameWithoutExtension(dto.FileName);
}
dto.ContentType = HttpUtility.HtmlDecode(i.Headers.ContentType.MediaType);
dto.Contents = new byte[(int)i.Headers.ContentLength];
Stream stream = i.ReadAsStreamAsync().Result;
stream.Read(dto.Contents, 0, (int)i.Headers.ContentLength);
}
});
});
task.Wait();
bindingContext.Model = dto;
return(true);
}
else
{
throw new HttpResponseException(request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted"));
}
}
public async Task <IActionResult> UploadFileAsync([FromBody] FileUploadDTO fileUploadDto)
{
var userId = _caller.Claims.Single(c => c.Type == "id");
return(Ok(await _fileUploadService.ProcessFileAsync(fileUploadDto)));
}
