public async Task <PaginationDto <BookGetDto> > GetAllAsync(BookQueryParams parameters)
{
if (parameters.LocationFilterOn == true &&
(parameters.HomeLocations == null || parameters.HomeLocations.Length == 0) &&
(parameters.Locations == null || parameters.Locations.Length == 0))
{
return(new PaginationDto <BookGetDto>()
{
TotalCount = 0,
Page = new List <BookGetDto>()
});
}
var query = GetFilteredQuery(_bookRepository.GetAll(), parameters);
if (parameters.HomeLocations?.Length > 0)
{
var queryBooksAtHome = GetFilteredQuery(_bookRepository.GetAll(), parameters, false);
query = query.Union(queryBooksAtHome);
}
if (parameters.SortableParams != null)
{
query = query.OrderBy(parameters.SortableParams);
}
return(await _paginationService.GetPageAsync <BookGetDto, Book>(query, parameters));
}
public async Task <PaginationDto <BookGetDto> > GetCurrentOwned(BookQueryParams parameters)
{
var userId = _userResolverService.GetUserId();
var query = _bookRepository.GetAll().Where(p => p.UserId == userId);
query = GetFilteredQuery(query, parameters);
return(await _paginationService.GetPageAsync <BookGetDto, Book>(query, parameters));
}
public async Task <PaginationDto <BookGetDto> > GetReadBooksAsync(BookQueryParams parameters)
{
var userId = _userResolverService.GetUserId();
var ownedBooks = _requestRepository.GetAll().Where(a => a.OwnerId == userId).Select(a => a.Book);
var currentlyOwnedBooks = _bookRepository.GetAll().Where(a => a.UserId == userId);
var readBooks = ownedBooks.Union(currentlyOwnedBooks);
var query = GetFilteredQuery(readBooks, parameters);
return(await _paginationService.GetPageAsync <BookGetDto, Book>(query, parameters));
}
public async Task <PaginationDto <BookGetDto> > GetRegisteredAsync(BookQueryParams parameters)
{
var userId = _userResolverService.GetUserId();
var registeredBooks = await FindRegisteredBooksAsync(userId);
var query = _bookRepository.GetAll().Where(x => registeredBooks.Contains(x.Id));
query = GetFilteredQuery(query, parameters);
return(await _paginationService.GetPageAsync <BookGetDto, Book>(query, parameters));
}
public async Task GetAllBooks_WhenHasSearchTermWithOneWord_Returns_books_filtered_by_LastName()
{
var booksMock = GetPopulatedBooks().AsQueryable().BuildMock();
_bookRepositoryMock.Setup(s => s.GetAll()).Returns(booksMock.Object);
var query = new BookQueryParams {
Page = 1, PageSize = 10, SearchTerm = "Martin"
};
var booksResult = await _bookService.GetAllAsync(query);
booksResult.Page.Should().HaveCount(1);
}
public async Task GetAllBooks_WhenHasShowAvailableTrue_Returns_available_books()
{
var booksMock = GetPopulatedBooks().AsQueryable().BuildMock();
_bookRepositoryMock.Setup(s => s.GetAll()).Returns(booksMock.Object);
var query = new BookQueryParams {
Page = 1, PageSize = 10, ShowAvailable = true
};
var booksResult = await _bookService.GetAllAsync(query);
booksResult.Page.Should().HaveCount(4);
}
public async Task GetAllBooks_WhenHasSearchTerm_Returns_books_filtered_by_Book_Title()
{
var booksMock = GetPopulatedBooks().AsQueryable().BuildMock();
_bookRepositoryMock.Setup(s => s.GetAll()).Returns(booksMock.Object);
var query = new BookQueryParams {
Page = 1, PageSize = 10, Languages = new[] { 1, 2, 3 }, SearchTerm = "CLR"
};
var booksResult = await _bookService.GetAllAsync(query);
booksResult.Page.Should().HaveCount(2);
}
public async Task GetAllBooks_WhenHasOneGenreId_Returns_books_containing_the_id()
{
var booksMock = GetPopulatedBooks().AsQueryable().BuildMock();
_bookRepositoryMock.Setup(s => s.GetAll()).Returns(booksMock.Object);
var query = new BookQueryParams {
Page = 1, PageSize = 10, Genres = new[] { 2 }
};
var booksResult = await _bookService.GetAllAsync(query);
booksResult.Page.Should().HaveCount(1);
}
public async Task GetAllBooks_WhenHasLocation_Returns_books_with_LocationId()
{
var booksMock = GetPopulatedBooks().AsQueryable().BuildMock();
_bookRepositoryMock.Setup(s => s.GetAll()).Returns(booksMock.Object);
var query = new BookQueryParams {
Page = 1, PageSize = 10, Locations = new int[] { 1 }
};
var booksResult = await _bookService.GetAllAsync(query);
booksResult.Page.Should().HaveCount(3);
}
public async Task GetAllBooks_ReturnsPaginatedBooks()
{
var booksMock = GetPopulatedBooks().AsQueryable().BuildMock();
_bookRepositoryMock.Setup(s => s.GetAll()).Returns(booksMock.Object);
var query = new BookQueryParams {
Page = 1, PageSize = 2
};
var booksResult = await _bookService.GetAllAsync(query);
booksResult.Should().BeOfType <PaginationDto <BookGetDto> >();
booksResult.Page.Should().HaveCount(2);
}
public async Task GetAllBooks_WheAllQueryParamsPresent_Returns_filtered_books()
{
var booksMock = GetPopulatedBooks().AsQueryable().BuildMock();
_bookRepositoryMock.Setup(s => s.GetAll()).Returns(booksMock.Object);
var query = new BookQueryParams
{
Page = 1,
PageSize = 10,
Locations = new [] { 1 },
Genres = new[] { 1 },
SearchTerm = "Martin",
ShowAvailable = true
};
var booksResult = await _bookService.GetAllAsync(query);
booksResult.Page.Should().HaveCount(1);
}
/// <inheritdoc />
public async Task <PaginationDto <RequestDto> > GetAsync(Expression <Func <Request, bool> > predicate, BookQueryParams parameters)
{
var books = _bookRepository.GetAll();
var author = _bookAuthorRepository.GetAll();
if (parameters.SearchTerm != null)
{
var term = parameters.SearchTerm.Split(" ");
if (term.Length <= 1)
{
author = author.Where(a =>
a.Author.FirstName.Contains(term[0]) || a.Author.LastName.Contains(term[0]) || a.Book.Name.Contains(parameters.SearchTerm));
}
else
{
author = author.Where(a =>
a.Author.FirstName.Contains(term[0]) && a.Author.LastName.Contains(term[term.Length - 1]) || a.Book.Name.Contains(parameters.SearchTerm));
}
}
var genre = _bookGenreRepository.GetAll();
if (parameters.Genres != null)
{
var wherePredicate = PredicateBuilder.New <BookGenre>();
foreach (var id in parameters.Genres)
{
var tempId = id;
wherePredicate = wherePredicate.Or(g => g.Genre.Id == tempId);
}
genre = genre.Where(wherePredicate);
}
var lang = _bookLanguageRepository.GetAll();
if (parameters.Languages != null)
{
var wherePredicate = PredicateBuilder.New <Language>();
foreach (var id in parameters.Languages)
{
var tempId = id;
wherePredicate = wherePredicate.Or(g => g.Id == tempId);
}
lang = lang.Where(wherePredicate);
}
if (parameters.ShowAvailable == true)
{
books = books.Where(b => b.State == BookState.Available);
}
var location = _userLocationRepository.GetAll();
if (parameters.Locations != null)
{
var wherePredicate = PredicateBuilder.New <UserRoom>();
foreach (var id in parameters.Locations)
{
var tempId = id;
wherePredicate = wherePredicate.Or(r => r.LocationId == tempId);
}
location = location.Where(wherePredicate);
}
var bookIds =
from b in books
join g in genre on b.Id equals g.BookId
join la in lang on b.Language.Id equals la.Id
join a in author on b.Id equals a.BookId
join l in location on b.User.UserRoomId equals l.Id
select b.Id;
var query = _requestRepository.GetAll()
.Include(i => i.Book).ThenInclude(i => i.BookAuthor).ThenInclude(i => i.Author)
.Include(i => i.Book).ThenInclude(i => i.BookGenre).ThenInclude(i => i.Genre)
.Include(i => i.Book).ThenInclude(i => i.Language)
.Include(i => i.Owner).ThenInclude(i => i.UserRoom).ThenInclude(i => i.Location)
.Include(i => i.User).ThenInclude(i => i.UserRoom).ThenInclude(i => i.Location)
.Where(predicate).Where(x => bookIds.Contains(x.BookId));
return(await _paginationService.GetPageAsync <RequestDto, Request>(query, parameters));
}
private IQueryable <Book> GetFilteredQuery(IQueryable <Book> query, BookQueryParams parameters, bool byLocation = true)
{
if (parameters.ShowAvailable == true)
{
query = query.Where(b => b.State == BookState.Available);
}
if (byLocation && parameters.Locations != null)
{
var predicate = PredicateBuilder.New <Book>();
foreach (var id in parameters.Locations)
{
var tempId = id;
predicate = predicate.Or(b =>
b.User.UserRoom.LocationId == id &&
(b.User.LocationHomeId == null || !b.User.LocationHome.IsActive)
);
}
query = query.Where(predicate);
}
if (!byLocation && parameters.HomeLocations != null)
{
var predicate = PredicateBuilder.New <Book>();
foreach (var id in parameters.HomeLocations)
{
var tempId = id;
predicate = predicate.Or(b =>
b.User.LocationHomeId == id &&
b.User.LocationHome.IsActive
);
}
query = query.Where(predicate);
}
if (parameters.SearchTerm != null)
{
var term = parameters.SearchTerm.Split(" ");
if (term.Length == 1)
{
query = query.Where(x => x.Name.Contains(parameters.SearchTerm) || x.BookAuthor.Any(a => a.Author.LastName.Contains(term[term.Length - 1]) || a.Author.FirstName.Contains(term[0])));
}
else
{
query = query.Where(x => x.Name.Contains(parameters.SearchTerm) || x.BookAuthor.Any(a => a.Author.LastName.Contains(term[term.Length - 1]) && a.Author.FirstName.Contains(term[0])));
}
}
if (parameters.Genres != null)
{
var predicate = PredicateBuilder.New <Book>();
foreach (var id in parameters.Genres)
{
var tempId = id;
predicate = predicate.Or(g => g.BookGenre.Any(g => g.Genre.Id == tempId));
}
query = query.Where(predicate);
}
if (parameters.Languages != null)
{
var predicate = PredicateBuilder.New <Book>();
foreach (var id in parameters.Languages)
{
predicate = predicate.Or(g => g.Language.Id == id);
}
query = query.Where(predicate);
}
return(query
.Include(p => p.BookAuthor)
.ThenInclude(x => x.Author)
.Include(p => p.BookGenre)
.ThenInclude(x => x.Genre)
.Include(x => x.Language)
.Include(p => p.User)
.ThenInclude(x => x.UserRoom)
.ThenInclude(x => x.Location)
.Include(x => x.Language));
}
public async Task <ActionResult <PaginationDto <BookGetDto> > > GetAllBooksAsync([FromQuery] BookQueryParams parameters)
{
return(await _bookService.GetAllAsync(parameters));
}
public async Task <ActionResult <PaginationDto <RequestDto> > > GetByUser([FromQuery] BookQueryParams query)
{
var userId = _userResolverService.GetUserId();
return(await _requestService.GetAsync(x => x.UserId == userId && x.ReceiveDate == null, query));
}
