public async Task <File> MakeAsync(CreateFileDto model)
{
model.CheckArgumentIsNull(nameof(model));
var utcNow = _dateService.UtcNow();
var file = new File {
CreateDate = utcNow,
CreatorUserId = _userContext.UserId,
Description = model.Description,
ModifierUserId = _userContext.UserId,
ModifyDate = utcNow,
Status = FileStatus.UnAttached,
WebsiteId = _websiteInfo.Id,
Title = model.Title
};
if (!string.IsNullOrWhiteSpace(model.FilePath))
{
file.FilePath = model.FileServerPath;
file.Extension = model.FilePath.GetFileExtension();
file.FileType = model.FilePath.GetPostFileType();
}
if (!string.IsNullOrWhiteSpace(model.Url))
{
file.Url = model.Url;
}
if (string.IsNullOrWhiteSpace(file.Title))
{
file.Title = model.FilePath.GetFileTitle();
}
return(await Task.FromResult(file));
}
public async Task <IActionResult> Post([FromBody] CreateFileDto fileDto)
{
if (fileDto?.Data == null)
{
return(BadRequest());
}
var imageDataByteArray = Convert.FromBase64String(fileDto.Data);
var seekableStream = new MemoryStream(imageDataByteArray)
{
Position = 0
};
await UploadImageToS3(seekableStream, fileDto.ImageName);
var fileMetadata = await UploadMetadataToRdc(imageDataByteArray, fileDto.ImageName);
var resultUrl = BuildFileUrl(fileDto.ImageName);
await _notificationService.PublishAsync(_topicArn, resultUrl);
_logger.LogInformation($"Uploaded object {fileDto.ImageName} to bucket {_bucketName}");
return(Created(resultUrl, null));
}
public async Task <IActionResult> AddFile([FromForm] CreateFileDto fileDto)
{
var result = await fileRepository.AddFile(fileDto);
switch (result.OperationResultType)
{
case OperationResultTypes.Exception:
return(new JsonResult("Exeption")
{
StatusCode = 400
});
case OperationResultTypes.Success:
return(new JsonResult(result.Result)
{
StatusCode = 200
});
case OperationResultTypes.NotExist:
return(new JsonResult("Unkown Error")
{
StatusCode = 204
});
case OperationResultTypes.Forbidden:
return(new JsonResult("Forbidden")
{
StatusCode = 403
});
}
return(new JsonResult(result.OperationResultMessage)
{
StatusCode = 500
});
}
public async Task Create(CreateFileDto input)
{
var @file = input.MapTo <ComlianceAndSafety.Files>();
@file = ComlianceAndSafety.Files.Create(AbpSession.GetTenantId(), input.CustomeFiledSetupId, input.Type, input.CustomField1, input.CustomField2, input.CustomField3, input.CustomField4, input.CustomField5, input.CustomField6, input.Category1, input.Category2, input.Category3, input.Category4, input.Category5, input.Path);
await _fileRepository.InsertAsync(@file);
}
public async Task <FileResultDto> CreateAsync(CreateFileDto model)
{
var file = await _factory.MakeAsync(model);
await _repository.AddAndSaveAsync(file);
return(await Task.FromResult(
file.Adapt <FileResultDto>()
));
}
private static MemoryStream GetFileStream(CreateFileDto fileDto)
{
var imageDataByteArray = Convert.FromBase64String(fileDto.Data);
var seekableStream = new MemoryStream(imageDataByteArray)
{
Position = 0
};
return(seekableStream);
}
public async Task <FileDto> UploadFile([FromForm] CreateFileDto createFileDto)
{
CreateFileValidator createfileValidator = new CreateFileValidator();
if (!createfileValidator.Validate(createFileDto.PhFile).IsValid)
{
throw new Exception("Name Not Valid... ");
}
//--------------- Upload Physical File ------------------//
var path = "";
if (createFileDto.FolderId > 0)
{
var rootFolder = (await _unitOfWork.FoldersRepository.GetAllIncluded(f => f.FolderId == createFileDto.FolderId)).SingleOrDefault();
if (rootFolder == null)
{
throw new Exception("Folder not found");
}
path = rootFolder.FolderPath + '\\' + createFileDto.PhFile.FileName;
}
else
{
path = _fileManager.GetRootPath() + createFileDto.PhFile.FileName;
}
_fileManager.UploadFile(createFileDto.PhFile, path);
//----------------------- Save to Db --------------------//
var entityFile = new Entities.File
{
FileName = Path.GetFileNameWithoutExtension(path),
FileExtension = Path.GetExtension(createFileDto.PhFile.FileName),
FileSize = int.Parse(createFileDto.PhFile.Length.ToString()),
FilePath = Path.GetFullPath(path),
FolderId = createFileDto.FolderId > 0 ? createFileDto.FolderId : default(int?)
};
var f = new FileInfo(Path.GetFullPath(path));
_unitOfWork.FileRepository.Add(entityFile);
await _unitOfWork.CompleteAsync();
return(_mapper.Map <Entities.File, FileDto>(entityFile));
}
//[Authorize] public async Task <IActionResult> UploadFile([FromForm] CreateFileDto fileDto) => Ok(await _postService.UploadFile(fileDto));
//public async Task<LikeOnPostDto> GetLike(int LikeId)
//{
// var po = await _unitOfWork.PostReposito
// var User = await _unitOfWork.UserRepository.GetUser(post.Userid);
// var p = _mapper.Map<Post, PostDtos>(post);
// p.Username = User.UserName;
// return p;
//}
public async Task <CreateFileDto> UploadFile([FromForm] CreateFileDto fileDto)
{
var user = await _unitOfWork.UserRepository.GetUser(fileDto.UserId);
var post = await _unitOfWork.PostRepository.GetPost(fileDto.Postid);
if (user == null)
{
throw new Exception("User not found");
}
if (post == null)
{
throw new Exception("post not Exist");
}
if (fileDto.File != null)
{
if (fileDto.File.Length > 0)
{
//Getting FileName
var fileName = Path.GetFileName(fileDto.File.FileName);
//Getting file Extension
var fileExtension = Path.GetExtension(fileDto.File.FileName);
var userid = fileDto.UserId;
var postid = fileDto.Postid;
// concatenating FileName + FileExtension
//var newFileName = string.Concat(Convert.ToString(Guid.NewGuid()), fileExtension);
var file = _mapper.Map <CreateFileDto, Modules.File>(fileDto);
var r = _mapper.Map <Modules.File, FileDto>(file);
var v = r.Username = user.UserName;
//return result;
var objfiles = new Modules.File()
{
//Username= p,
FileName = fileName,
UserId = userid,
PostId = postid,
Username = v,
ContentType = fileExtension
};
//var path = @"C:\\User\\DELL\\source\\repos\\FirstTask\\FirstTask\\Core\\Entities";
//var FileInfo = new FileInfo(path);
//FileInfo.CopyTo(path);
//using (var target = new MemoryStream())
//{
// fileDto.File.CopyTo(target);
// // objfiles. = target.ToArray();
//}
_unitOfWork.fileRepository.Add(objfiles);
await _unitOfWork.CompleteAsync();
}
var Attachment = _mapper.Map <CreateFileDto, Modules.File>(fileDto);
await _unitOfWork.CompleteAsync();
var result = _mapper.Map <Modules.File, CreateFileDto>(Attachment);
return(result);
}
return(View());
}
