public async Task DeleteFolderAsync(UserDto userDto, string id)
{
var user = mapper.Map <UserDto, User>(userDto);
if (Guid.TryParse(id, out Guid storageItemId) == false)
{
throw new ArgumentException($"{id} is not valid id");
}
var folderToDelete =
await unitOfWork.StorageItems.GetFolderByUserAndFolderIdAsync(user, storageItemId);
if (folderToDelete == null)
{
throw new ArgumentException("Folder doesn't exists");
}
string fullPath = StorageItemsHelpers.GetStorageItemFullPath(targetPath, folderToDelete.RelativePath);
if (!folderManager.IsFolderExists(fullPath))
{
folderManager.DeleteFolder(fullPath);
}
unitOfWork.StorageItems.Remove(folderToDelete);
await unitOfWork.CommitAsync();
}
public async Task <FileItemDto> CreateFileAsync(UserDto userDto, IFormFile file)
{
var user = mapper.Map <UserDto, User>(userDto);
var primaryFolder = await unitOfWork.StorageItems.GetUserPrimaryFolderAsync(user);
if (primaryFolder == null)
{
throw new ArgumentNullException("User doesn't have primary folder");
}
else
{
try
{
var formFileContent = await file.ProcessFormFileAsync(fileSizeLimit);
var fileItem = file.CreateFileItemFormFile(primaryFolder, user);
string fullPath = StorageItemsHelpers.GetStorageItemFullPath(targetPath, fileItem.RelativePath);
await fileManager.CreateFileAsync(fullPath, formFileContent);
await unitOfWork.StorageItems.AddAsync(fileItem);
await unitOfWork.CommitAsync();
var fileDto = mapper.Map <StorageItem, FileItemDto>(fileItem);
return(fileDto);
}
catch (Exception ex)
{
throw ex;
}
}
}
public async Task <StorageItem> CreateFolderAsync(FolderCreateRequestDto folderCreate)
{
var folder = mapper.Map <FolderCreateRequestDto, StorageItem>(folderCreate);
folder.TrustedName = StorageItemsHelpers.GetStorageItemTrustedName();
folder.RelativePath = StorageItemsHelpers.GetFolderRelativePath(folder);
var existingFolderInDirectory =
await unitOfWork.StorageItems.GetFolderByTrustedNameAsync(folder.TrustedName);
string fullPath = StorageItemsHelpers.GetStorageItemFullPath(targetPath, folder.RelativePath);
if (existingFolderInDirectory == null && !folderManager.IsFolderExists(fullPath))
{
await unitOfWork.StorageItems.AddAsync(folder);
await unitOfWork.CommitAsync();
folderManager.CreateFolder(fullPath);
return(folder);
}
else
{
throw new ArgumentException("Folder has been already exists!");
}
}
public async Task DeleteFileAsync(string fileId)
{
var file = await GetActualItemByIdAsync(fileId);
var filePath = StorageItemsHelpers.GetStorageItemFullPath(targetPath, file.RelativePath);
fileManager.DeleteFile(filePath);
unitOfWork.StorageItems.Remove(file);
await unitOfWork.CommitAsync();
}
public async Task DeleteRecycledItemAsync(UserDto userDto, string fileId)
{
var file = await GetRecycledItemByUserAndItemIdAsync(userDto, fileId);
var filePath = StorageItemsHelpers.GetStorageItemFullPath(targetPath, file.RelativePath);
fileManager.DeleteFile(filePath);
unitOfWork.StorageItems.Remove(file);
await unitOfWork.CommitAsync();
}
public async Task <(MemoryStream stream, string contentType, string fileName)> DownloadFileAsync(
UserDto userDto, string fileId)
{
var fileItem = await GetActualItemByUserAndItemIdAsync(userDto, fileId);
var filePath = StorageItemsHelpers.GetStorageItemFullPath(targetPath, fileItem.RelativePath);
var stream = await fileManager.ReadFileAsync(filePath);
stream.Position = 0;
return(stream, StorageItemsHelpers.GetContentType(filePath), fileItem.DisplayName);
}
public void Exception_Relative_File_Path_For_Folder()
{
var file = new StorageItem()
{
DisplayName = "testDisplay",
TrustedName = "testTrust",
IsFolder = true
};
Assert.That(() => StorageItemsHelpers.GetFileRelativePath(file),
Throws.TypeOf <ArgumentException>()
.With.Matches <ArgumentException>(
ex => ex.Message == "Item should be a file."));
}
public void Exception_Relative_File_Path_Without_Parent_Folder()
{
var folder = new StorageItem()
{
DisplayName = "testDisplay",
TrustedName = "testTrust",
IsFolder = false,
ParentFolder = null
};
Assert.That(() => StorageItemsHelpers.GetFileRelativePath(folder),
Throws.TypeOf <ArgumentException>()
.With.Matches <ArgumentException>(
ex => ex.Message == "File should contain a parent folder."));
}
public void Exception_Relative_NonPrimary_Folder_Path_Without_Parent()
{
var folder = new StorageItem()
{
DisplayName = "testDisplay",
TrustedName = "testTrust",
IsFolder = true,
IsPrimaryFolder = false,
ParentFolder = null
};
Assert.That(() => StorageItemsHelpers.GetFolderRelativePath(folder),
Throws.TypeOf <ArgumentException>()
.With.Matches <ArgumentException>(
ex => ex.Message == "Non-primary folder should have a parent folder"));
}
public async Task <(MemoryStream stream, string contentType, string fileName)> DownloadFileAsync(string fileId)
{
if (Guid.TryParse(fileId, out Guid storageItemId) == false)
{
throw new ArgumentException($"{fileId} is not valid id");
}
var fileItem = await unitOfWork.StorageItems.GetPublicFileByIdAsync(storageItemId);
if (fileItem == null)
{
throw new StorageItemNotFoundException($"File for current user does not exist.");
}
var filePath = StorageItemsHelpers.GetStorageItemFullPath(targetPath, fileItem.RelativePath);
var stream = await fileManager.ReadFileAsync(filePath);
stream.Position = 0;
return(stream, StorageItemsHelpers.GetContentType(filePath), fileItem.DisplayName);
}
