public async void Returns_ParentDirectoryOfDeletingFile_when_FileExistAndBelongsToUser()
{
Guid parentId = Guid.NewGuid();
StatusCode <DirectoryOut> status = new StatusCode <DirectoryOut>(StatusCodes.Status200OK, new DirectoryOut
{
ID = parentId
});
Mock <IFileService> fileService = new Mock <IFileService>();
fileService.Setup(_ => _.DeleteByIdAndUser(It.IsAny <Guid>(), It.IsAny <string>()))
.Returns(Task.FromResult(status));
string username = "******";
FilesController filesController = new FilesController(fileService.Object, UserManagerHelper.GetUserManager(username));
filesController.Authenticate(username);
IActionResult result = await filesController.Delete(Guid.NewGuid());
OkObjectResult okObjectResult = result as OkObjectResult;
Assert.NotNull(okObjectResult);
DirectoryOut parentDirectoryOut = okObjectResult.Value as DirectoryOut;
Assert.NotNull(parentDirectoryOut);
Assert.Equal(parentId, parentDirectoryOut.ID);
}
public async void Returns_DirectoryOut_when_DirectoryExistAndBelongsToUser()
{
DirectoryOut directory = new DirectoryOut
{
ID = Guid.NewGuid(),
Name = Guid.NewGuid().ToString(),
Files = new List <FileOut>()
{
new FileOut()
{
ID = Guid.NewGuid(),
Name = Guid.NewGuid().ToString()
}
}
};
Mock <IFileService> fileService = new Mock <IFileService>();
fileService.Setup(_ => _.GetDirectoryByIdAndUser(It.IsAny <Guid>(), It.IsAny <string>()))
.Returns(Task.FromResult(new StatusCode <DirectoryOut>(StatusCodes.Status200OK, directory)));
string username = "******";
FilesController filesController = new FilesController(fileService.Object, UserManagerHelper.GetUserManager(username));
filesController.Authenticate(username);
IActionResult result = await filesController.GetFromDirectory(Guid.NewGuid());
OkObjectResult okObjectResult = result as OkObjectResult;
Assert.NotNull(okObjectResult);
Assert.IsType <DirectoryOut>(okObjectResult.Value);
}
public async Task <StatusCode <DirectoryOut> > CreateDirectoryByUser(DirectoryPost directoryPost, string username)
{
string userId = (await _databaseContext.Users.FirstOrDefaultAsync(_ => _.UserName == username))?.Id;
if (directoryPost.ParentDirectoryID != null && !_databaseContext.Directories.AnyAsync(_ => _.OwnerID == userId && _.ID == directoryPost.ParentDirectoryID).Result)
{
return(new StatusCode <DirectoryOut>(StatusCodes.Status404NotFound, StatusMessages.PARENT_DIRECTORY_NOT_FOUND));
}
string nameForNewDirectory = directoryPost.Name;
Directory newDirectory = new Directory
{
CreatedDateTime = DateTime.Now,
ResourceType = ResourceType.DIRECTORY,
Name = nameForNewDirectory,
OwnerID = userId,
ParentDirectoryID = directoryPost.ParentDirectoryID
};
await _databaseContext.Directories.AddAsync(newDirectory);
await _databaseContext.SaveChangesAsync();
DirectoryOut result = _mapper.Map <DirectoryOut>(newDirectory);
return(new StatusCode <DirectoryOut>(StatusCodes.Status201Created, result));
}
public async Task <StatusCode <DirectoryOut> > GetDirectoryByIdAndUser(Guid?id, string username)
{
string userId = (await _databaseContext.Users.FirstOrDefaultAsync(_ => _.UserName == username))?.Id;
DirectoryOut result;
if (id != null)
{
Directory directory = await _databaseContext.Directories
.Include(_ => _.Files)
.Include(_ => _.ParentDirectory)
.FirstOrDefaultAsync(_ => _.ID == id && _.OwnerID == userId);
if (directory == null)
{
return(new StatusCode <DirectoryOut>(StatusCodes.Status404NotFound, StatusMessages.DIRECTORY_NOT_FOUND));
}
if (directory.ParentDirectory == null)
{
directory.ParentDirectory = new Directory
{
CreatedDateTime = DateTime.Now,
ResourceType = ResourceType.DIRECTORY,
LastModifiedDateTime = DateTime.Now,
Name = "Root"
};
}
result = _mapper.Map <DirectoryOut>(directory);
}
else
{
List <ResourceAbstract> files = await _databaseContext.ResourceAbstracts
.Where(_ => _.ParentDirectoryID == id && _.OwnerID == userId &&
(_.ResourceType == ResourceType.DIRECTORY || _.ResourceType == ResourceType.FILE))
.ToListAsync();
result = new DirectoryOut
{
CreatedDateTime = DateTime.Now,
Files = _mapper.Map <List <FileOut> >(files),
ResourceType = ResourceType.DIRECTORY,
LastModifiedDateTime = DateTime.Now,
Name = "Root"
};
}
int[] sortingMap = new[] { 2, 1, 3 };
result.Files = result.Files.OrderBy(_ => sortingMap[(int)(_.ResourceType)]).ThenBy(_ => _.Name).ThenBy(_ => _.ID).ToList();
return(new StatusCode <DirectoryOut>(StatusCodes.Status200OK, result));
}
public async Task <StatusCode <DirectoryOut> > DeleteByIdAndUser(Guid id, string username)
{
ApplicationUser user = await _databaseContext.Users.FirstOrDefaultAsync(_ => _.UserName == username);
string userId = user?.Id;
ResourceAbstract fileAbstractToDelete = await _databaseContext.ResourceAbstracts
.FirstOrDefaultAsync(_ => _.ID == id && _.OwnerID == userId);
if (fileAbstractToDelete == null)
{
return(new StatusCode <DirectoryOut>(StatusCodes.Status404NotFound, StatusMessages.FILE_NOT_FOUND));
}
List <ShareAbstract> shares = await _databaseContext.ShareAbstracts
.Where(_ => _.ResourceID == fileAbstractToDelete.ID)
.ToListAsync();
_databaseContext.ShareAbstracts.RemoveRange(shares);
Guid?parentDirectoryId = fileAbstractToDelete.ParentDirectoryID;
if (fileAbstractToDelete is File)
{
File fileToDelete = fileAbstractToDelete as File;
System.IO.File.Delete(fileToDelete.Path);
if (System.IO.File.Exists(fileToDelete.Path))
{
return(new StatusCode <DirectoryOut>(StatusCodes.Status400BadRequest, StatusMessages.CANNOT_DELETE_FILE));
}
user.UsedDiskSpace -= fileToDelete.FileSizeBytes;
_databaseContext.Files.Remove(fileToDelete);
await _databaseContext.SaveChangesAsync();
}
else if (fileAbstractToDelete is Directory)
{
Directory directoryToDelete = await _databaseContext.Directories
.Include(_ => _.Files)
.FirstOrDefaultAsync(_ => _.ID == fileAbstractToDelete.ID && _.OwnerID == userId);
foreach (ResourceAbstract fileAbstract in directoryToDelete.Files.ToList())
{
await DeleteByIdAndUser(fileAbstract.ID, username);
}
_databaseContext.Directories.Remove(directoryToDelete);
await _databaseContext.SaveChangesAsync();
}
DirectoryOut parentDirectoryOutResult = null;
if (parentDirectoryId != null)
{
Directory directoryToReturn = await _databaseContext.Directories
.Include(_ => _.Files)
.Include(_ => _.ParentDirectory)
.FirstOrDefaultAsync(_ => _.ID == parentDirectoryId && _.OwnerID == userId);
parentDirectoryOutResult = _mapper.Map <DirectoryOut>(directoryToReturn);
}
else
{
List <ResourceAbstract> files = await _databaseContext.ResourceAbstracts
.Include(_ => _.ParentDirectory)
.Where(_ => _.ParentDirectoryID == null && _.OwnerID == userId)
.ToListAsync();
parentDirectoryOutResult = new DirectoryOut
{
ID = null,
Files = _mapper.Map <List <FileOut> >(files),
ResourceType = ResourceType.DIRECTORY,
Name = "root",
ParentDirectoryID = null,
ParentDirectoryName = null
};
}
return(new StatusCode <DirectoryOut>(StatusCodes.Status200OK, StatusMessages.FILE_DELETED, parentDirectoryOutResult));
}
