public async Task <StatusCode <NoteOut> > GetByIdAndUser(Guid noteId, string username)
{
string userId = (await _databaseContext.Users
.FirstOrDefaultAsync(_ => _.UserName == username))?
.Id;
Note note = await _databaseContext.Notes
.Include(_ => _.ShareEveryone)
.Include(_ => _.ShareForUsers)
.FirstOrDefaultAsync(_ => _.ID == noteId);
if (note == null)
{
return(new StatusCode <NoteOut>(StatusCodes.Status404NotFound, $"Note {noteId} not found"));
}
if (note.OwnerID == userId)
{
return(new StatusCode <NoteOut>(StatusCodes.Status200OK, _mapper.Map <NoteOut>(note)));
}
if (note.IsShared)
{
if (note.IsSharedForEveryone)
{
ShareEveryone share = note.ShareEveryone;
if (share != null)
{
if ((share.ExpirationDateTime == null ||
(share.ExpirationDateTime != null && share.ExpirationDateTime >= DateTime.Now)) &&
(share.DownloadLimit == null ||
(share.DownloadLimit != null && share.DownloadLimit > 0)))
{
return(new StatusCode <NoteOut>(StatusCodes.Status200OK, _mapper.Map <NoteOut>(note)));
}
}
}
else if (note.IsSharedForUsers)
{
ShareForUser share = note.ShareForUsers.FirstOrDefault(_ => _.SharedForUserID == userId && _.ResourceID == noteId);
if (share != null)
{
if (share.ExpirationDateTime == null ||
(share.ExpirationDateTime != null && share.ExpirationDateTime >= DateTime.Now))
{
return(new StatusCode <NoteOut>(StatusCodes.Status200OK, _mapper.Map <NoteOut>(note)));
}
}
}
}
return(new StatusCode <NoteOut>(StatusCodes.Status404NotFound, $"Note {noteId} not found"));
}
public async void Returns_OkObjectResult200AndNoteOut_when_NoteExistsAndIsSharedForEveryoneAndDownloadLimitIsGreaterThan0()
{
IDatabaseContext databaseContext = DatabaseTestHelper.GetContext();
MapperConfiguration mapperConfiguration = new MapperConfiguration(conf =>
{
conf.AddProfile(new Note_to_NoteOut());
});
IMapper mapper = mapperConfiguration.CreateMapper();
INotesService notesService = new NotesService(databaseContext, mapper);
string userId = (await databaseContext.Users.FirstOrDefaultAsync(_ => _.UserName == ADMIN_USERNAME)).Id;
Note note = new Note
{
ResourceType = DAO.Models.Base.ResourceType.NOTE,
Title = "Note's title",
Content = "Note's content",
OwnerID = userId,
CreatedDateTime = DateTime.Now,
IsShared = true,
IsSharedForEveryone = true
};
await databaseContext.Notes.AddAsync(note);
int downloadLimit = 5;
ShareEveryone shareEveryone = new ShareEveryone
{
CreatedDateTime = DateTime.Now,
ResourceID = note.ID,
OwnerID = userId,
Token = "XYZ",
DownloadLimit = downloadLimit
};
await databaseContext.ShareEveryones.AddAsync(shareEveryone);
await databaseContext.SaveChangesAsync();
Assert.True(databaseContext.Notes
.Any(_ => _.ID == note.ID));
Assert.True(databaseContext.ShareEveryones
.Any(_ => _.ID == shareEveryone.ID));
StatusCode <NoteOut> status = await notesService.GetByIdAndUser(note.ID, USER_USERNAME);
Assert.NotNull(status);
Assert.Equal(StatusCodes.Status200OK, status.Code);
Assert.NotNull(status.Body);
Assert.IsType <NoteOut>(status.Body);
Assert.Equal(downloadLimit, shareEveryone.DownloadLimit);
}
public async Task <StatusCode <ShareEveryoneOut> > ShareForEveryone(Guid resourceId, string username, string password, DateTime?expirationDateTime, int?downloadLimit)
{
string userId = (await _databaseContext.Users.FirstOrDefaultAsync(_ => _.UserName == username))?.Id;
ResourceAbstract resourceAbstract = await _databaseContext.ResourceAbstracts.FirstOrDefaultAsync(_ => _.ID == resourceId && _.OwnerID == userId);
if (resourceAbstract == null)
{
return(new StatusCode <ShareEveryoneOut>(StatusCodes.Status404NotFound, StatusMessages.FILE_NOT_FOUND));
}
ShareEveryone shareEveryone = await _databaseContext.ShareEveryones.FirstOrDefaultAsync(_ => _.ResourceID == resourceId && _.OwnerID == userId);
if (shareEveryone == null)
{
shareEveryone = new ShareEveryone
{
CreatedDateTime = DateTime.Now,
DownloadLimit = downloadLimit,
ExpirationDateTime = expirationDateTime,
ResourceID = resourceId,
OwnerID = userId,
Password = password,
Token = GenerateToken()
};
await _databaseContext.ShareEveryones.AddAsync(shareEveryone);
resourceAbstract.IsShared = true;
resourceAbstract.IsSharedForEveryone = true;
}
else
{
shareEveryone.DownloadLimit = downloadLimit;
shareEveryone.ExpirationDateTime = expirationDateTime;
shareEveryone.Password = password;
shareEveryone.LastModifiedDateTime = DateTime.Now;
}
if (shareEveryone.ExpirationDateTime.HasValue)
{
shareEveryone.ExpirationDateTime = shareEveryone.ExpirationDateTime.Value.AddHours(1);
}
await _databaseContext.SaveChangesAsync();
ShareEveryoneOut result = _mapper.Map <ShareEveryoneOut>(shareEveryone);
return(new StatusCode <ShareEveryoneOut>(StatusCodes.Status200OK, result));
}
public async Task <StatusCode <ShareEveryoneOut> > GetShareForEveryoneByFileIdAndUser(Guid resourceId, string username)
{
string userId = (await _databaseContext.Users
.FirstOrDefaultAsync(_ => _.UserName == username))
?.Id;
ShareEveryone shareEveryone = await _databaseContext.ShareEveryones
.FirstOrDefaultAsync(_ => _.ResourceID == resourceId && _.OwnerID == userId);
if (shareEveryone == null)
{
return(new StatusCode <ShareEveryoneOut>(StatusCodes.Status404NotFound, StatusMessages.FILE_IS_NOT_SHARED));
}
ShareEveryoneOut result = _mapper.Map <ShareEveryoneOut>(shareEveryone);
return(new StatusCode <ShareEveryoneOut>(StatusCodes.Status200OK, result));
}
public async void Returns_False_when_FileNotBelongsToUser()
{
IDatabaseContext databaseContext = DatabaseTestHelper.GetContext();
IShareService shareService = new ShareService(databaseContext, null);
string ownerUsername = "******";
ApplicationUser owner = await databaseContext.Users.FirstOrDefaultAsync(_ => _.UserName == ownerUsername);
Assert.NotNull(owner);
File file = new File
{
ParentDirectoryID = null,
Name = "TestFile.txt",
OwnerID = owner.Id,
IsShared = true,
IsSharedForEveryone = true,
ResourceType = DAO.Models.Base.ResourceType.FILE
};
await databaseContext.Files.AddAsync(file);
ShareEveryone shareFile = new ShareEveryone
{
CreatedDateTime = DateTime.Now,
ResourceID = file.ID,
OwnerID = owner.Id,
Token = "fil_token"
};
await databaseContext.ShareEveryones.AddAsync(shareFile);
await databaseContext.SaveChangesAsync();
bool isSharedForEveryone = await shareService.IsSharedForEveryone(file.ID);
Assert.True(isSharedForEveryone);
bool canceled = await shareService.CancelSharingForEveryone(file.ID, "*****@*****.**");
Assert.False(canceled);
Assert.True(await databaseContext.ShareEveryones.AnyAsync(_ => _.ResourceID == file.ID));
}
public async Task <StatusCode <ShareEveryoneOut> > GetShareForEveryoneByTokenAndPassword(string token, string password)
{
ShareEveryone shareEveryone = await _databaseContext.ShareEveryones
.Include(_ => _.Owner)
.Include(_ => _.Resource)
.FirstOrDefaultAsync(_ => _.Token == token);
if (shareEveryone == null)
{
return(new StatusCode <ShareEveryoneOut>(StatusCodes.Status404NotFound, StatusMessages.TOKEN_NOT_FOUND));
}
if (shareEveryone.Password != password)
{
return(new StatusCode <ShareEveryoneOut>(StatusCodes.Status401Unauthorized, StatusMessages.PASSWORD_IS_WRONG));
}
ShareEveryoneOut shareEveryoneOut = _mapper.Map <ShareEveryoneOut>(shareEveryone);
return(new StatusCode <ShareEveryoneOut>(StatusCodes.Status200OK, shareEveryoneOut));
}
public async Task <bool> CancelSharingForEveryone(Guid resourceId, string username)
{
string userId = (await _databaseContext.Users.FirstOrDefaultAsync(_ => _.UserName == username))?.Id;
ResourceAbstract fileAbstract = await _databaseContext.ResourceAbstracts.FirstOrDefaultAsync(_ => _.ID == resourceId && _.OwnerID == userId);
ShareEveryone shareEveryone = await _databaseContext.ShareEveryones.FirstOrDefaultAsync(_ => _.ResourceID == resourceId && _.OwnerID == userId);
if (fileAbstract == null || shareEveryone == null)
{
return(false);
}
_databaseContext.ShareEveryones.Remove(shareEveryone);
fileAbstract.IsSharedForEveryone = false;
fileAbstract.IsShared = fileAbstract.IsSharedForUsers;
await _databaseContext.SaveChangesAsync();
return(!fileAbstract.IsSharedForEveryone &&
!(await _databaseContext.ShareEveryones.AnyAsync(_ => _.ResourceID == resourceId && _.OwnerID == userId)));
}
public async void Returns_True_when_DirectoryIsSharedForEveryone()
{
IDatabaseContext databaseContext = DatabaseTestHelper.GetContext();
IShareService shareService = new ShareService(databaseContext, null);
string ownerUsername = "******";
ApplicationUser owner = await databaseContext.Users.FirstOrDefaultAsync(_ => _.UserName == ownerUsername);
Assert.NotNull(owner);
Directory directory = new Directory
{
ParentDirectoryID = null,
Name = "TestDirectory",
OwnerID = owner.Id,
IsShared = true,
IsSharedForEveryone = true,
ResourceType = DAO.Models.Base.ResourceType.DIRECTORY
};
await databaseContext.Directories.AddAsync(directory);
ShareEveryone shareDirectory = new ShareEveryone
{
CreatedDateTime = DateTime.Now,
ResourceID = directory.ID,
OwnerID = owner.Id,
Token = "dir_token"
};
await databaseContext.ShareEveryones.AddAsync(shareDirectory);
await databaseContext.SaveChangesAsync();
bool isSharedForEveryone = await shareService.IsSharedForEveryone(directory.ID);
Assert.True(isSharedForEveryone);
}
public async Task <bool> IsSharedForEveryone(Guid resourceId)
{
ShareEveryone shareEveryone = await _databaseContext.ShareEveryones.FirstOrDefaultAsync(_ => _.ResourceID == resourceId);
return(shareEveryone != null);
}
public async Task <StatusCode <FileOut> > GetByIdAndUser(Guid id, string username)
{
string userId = (await _databaseContext.Users
.FirstOrDefaultAsync(_ => _.UserName == username))?.Id;
ResourceAbstract fileAbstract = await _databaseContext.ResourceAbstracts
.Include(_ => _.ParentDirectory)
.Include(_ => _.ShareEveryone)
.Include(_ => _.ShareForUsers)
.FirstOrDefaultAsync(_ => _.ID == id && (_.ResourceType == ResourceType.FILE || _.ResourceType == ResourceType.DIRECTORY));
if (fileAbstract == null)
{
return(new StatusCode <FileOut>(StatusCodes.Status404NotFound, $"File {id} not found"));
}
if (fileAbstract.OwnerID == userId)
{
FileOut result = _mapper.Map <FileOut>(fileAbstract);
if (fileAbstract is File)
{
result.FileSizeBytes = (fileAbstract as File).FileSizeBytes;
}
return(new StatusCode <FileOut>(StatusCodes.Status200OK, result));
}
if (fileAbstract.IsShared)
{
if (fileAbstract.IsSharedForEveryone)
{
ShareEveryone share = fileAbstract.ShareEveryone;
if (share != null)
{
if ((share.ExpirationDateTime == null ||
(share.ExpirationDateTime != null && share.ExpirationDateTime >= DateTime.Now)) &&
(share.DownloadLimit == null ||
(share.DownloadLimit != null && share.DownloadLimit > 0)))
{
FileOut result = _mapper.Map <FileOut>(fileAbstract);
if (fileAbstract is File)
{
result.FileSizeBytes = (fileAbstract as File).FileSizeBytes;
}
return(new StatusCode <FileOut>(StatusCodes.Status200OK, result));
}
}
}
else if (fileAbstract.IsSharedForUsers)
{
ShareForUser share = fileAbstract.ShareForUsers.FirstOrDefault(_ => _.SharedForUserID == userId && _.ResourceID == id);
if (share != null)
{
if (share.ExpirationDateTime == null ||
(share.ExpirationDateTime != null && share.ExpirationDateTime >= DateTime.Now))
{
FileOut result = _mapper.Map <FileOut>(fileAbstract);
if (fileAbstract is File)
{
result.FileSizeBytes = (fileAbstract as File).FileSizeBytes;
}
return(new StatusCode <FileOut>(StatusCodes.Status200OK, result));
}
}
}
}
return(new StatusCode <FileOut>(StatusCodes.Status404NotFound, $"File {id} not found"));
}
public async Task <StatusCode <DownloadFileInfo> > DownloadByIdAndUser(Guid id, string username)
{
string userId = (await _databaseContext.Users.FirstOrDefaultAsync(_ => _.UserName == username))?.Id;
File fileToDownload = await _databaseContext.Files
.Include(_ => _.ShareEveryone)
.Include(_ => _.ShareForUsers)
.FirstOrDefaultAsync(_ => _.ID == id);
if (fileToDownload == null)
{
return(new StatusCode <DownloadFileInfo>(StatusCodes.Status404NotFound, $"File {id} not found"));
}
if (fileToDownload.OwnerID == userId)
{
byte[] fileContent = System.IO.File.ReadAllBytes(fileToDownload.Path);
DownloadFileInfo downloadFileInfo = new DownloadFileInfo(fileToDownload.Name, fileContent);
return(new StatusCode <DownloadFileInfo>(StatusCodes.Status200OK, downloadFileInfo));
}
if (fileToDownload.IsShared)
{
if (fileToDownload.IsSharedForEveryone)
{
ShareEveryone share = fileToDownload.ShareEveryone;
if (share != null)
{
if ((share.ExpirationDateTime == null ||
(share.ExpirationDateTime != null && share.ExpirationDateTime >= DateTime.Now)) &&
(share.DownloadLimit == null ||
(share.DownloadLimit != null && share.DownloadLimit > 0)))
{
if (share.DownloadLimit != null && share.DownloadLimit > 0)
{
--share.DownloadLimit;
await _databaseContext.SaveChangesAsync();
}
byte[] fileContent = System.IO.File.ReadAllBytes(fileToDownload.Path);
DownloadFileInfo downloadFileInfo = new DownloadFileInfo(fileToDownload.Name, fileContent);
return(new StatusCode <DownloadFileInfo>(StatusCodes.Status200OK, downloadFileInfo));
}
}
}
else if (fileToDownload.IsSharedForUsers)
{
ShareForUser share = fileToDownload.ShareForUsers.FirstOrDefault(_ => _.SharedForUserID == userId && _.ResourceID == id);
if (share != null)
{
if (share.ExpirationDateTime == null ||
(share.ExpirationDateTime != null && share.ExpirationDateTime >= DateTime.Now))
{
byte[] fileContent = System.IO.File.ReadAllBytes(fileToDownload.Path);
DownloadFileInfo downloadFileInfo = new DownloadFileInfo(fileToDownload.Name, fileContent);
return(new StatusCode <DownloadFileInfo>(StatusCodes.Status200OK, downloadFileInfo));
}
}
}
}
return(new StatusCode <DownloadFileInfo>(StatusCodes.Status404NotFound, $"File {id} not found"));
}
