public ActionResult <IEnumerable <BookWithoutQuotesDto> > GetBooks(
[FromQuery] BooksResourceParameters booksResourceParameters)
{
var books = _bookInfoRepository.GetBooks(booksResourceParameters);
return(Ok(_mapper.Map <IEnumerable <BookWithoutQuotesDto> >(books)));
}
private string CreateBooksResourceUri(BooksResourceParameters booksResourceParameters,
ResourceUriType resourceUriType)
{
return(resourceUriType switch
{
ResourceUriType.PreviousPage => Url.Link(nameof(GetBooksForAuthor),
new
{
fields = booksResourceParameters.Fields,
pageNumber = booksResourceParameters.PageNumber - 1,
pageSize = booksResourceParameters.PageSize,
searchTitle = booksResourceParameters.SearchTitle
}),
ResourceUriType.NextPage => Url.Link(nameof(GetBooksForAuthor),
new
{
fields = booksResourceParameters.Fields,
pageNumber = booksResourceParameters.PageNumber + 1,
pageSize = booksResourceParameters.PageSize,
searchTitle = booksResourceParameters.SearchTitle
}),
ResourceUriType.Current => Url.Link(nameof(GetBooksForAuthor),
new
{
fields = booksResourceParameters.Fields,
pageNumber = booksResourceParameters.PageNumber,
pageSize = booksResourceParameters.PageSize,
searchTitle = booksResourceParameters.SearchTitle
}),
_ => throw new NotImplementedException(),
});
public IActionResult GetBooks(BooksResourceParameters booksResourcesParameters)
{
try
{
var books = _repository.GetBooks(booksResourcesParameters);
var previousPageLink = books.HasPrevious
? CreateBooksResourceUri(booksResourcesParameters, ResourceUriType.PreviousPage)
: null;
var nextPageLink = books.HasNext
? CreateBooksResourceUri(booksResourcesParameters, ResourceUriType.NextPage)
: null;
var paginationMetadata = new
{
totalCount = books.TotalCount,
pageSize = books.PageSize,
currentPage = books.CurrentPage,
totalPages = books.TotalPages,
previousPageLink = previousPageLink,
nextPageLink = nextPageLink
};
Response.Headers.Add("X-Pagination",
Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetadata));
return(Ok(Mapper.Map <IEnumerable <BookViewModel> >(books)));
}
catch (Exception ex)
{
_logger.LogError("Failed to load books : {0}", ex);
}
return(BadRequest("Failed to load books"));
}
public IEnumerable <Book> GetBooks(BooksResourceParameters booksResourceParameters)
{
if (string.IsNullOrWhiteSpace(booksResourceParameters.Genre) &&
string.IsNullOrWhiteSpace(booksResourceParameters.SearchQuery))
{
return(GetBooks());
}
var booksToQuery = _context.Books as IQueryable <Book>;
if (!string.IsNullOrWhiteSpace(booksResourceParameters.Genre))
{
var genre = booksResourceParameters.Genre.Trim();
booksToQuery = booksToQuery.Where(b => b.Genre == genre);
}
if (!string.IsNullOrWhiteSpace(booksResourceParameters.SearchQuery))
{
var searchQuery = booksResourceParameters.SearchQuery.Trim();
booksToQuery = booksToQuery.Where(b =>
b.Author.Contains(searchQuery) ||
b.Description.Contains(searchQuery) ||
b.Genre.Contains(searchQuery) ||
b.Title.Contains(searchQuery)
);
}
return(booksToQuery.ToList());
}
public async Task <IActionResult> GetBooks(Guid authorId,
[FromQuery] BooksResourceParameters booksResourceParameters)
{
var books = await _bookRepository.GetBooksForAuthorAsync(authorId,
booksResourceParameters);
return(Ok(books));
}
public IActionResult GetBooks([FromQuery] BooksResourceParameters parameters)
{
var books = _bookService.GetBooks(parameters);
var bookDtos = MapBookToBookDto(books);
AddCoversToBookDtos(books, bookDtos);
return(Ok(new PagedList <BookDto>(bookDtos.AsQueryable(), parameters.PageNumber, parameters.PageSize)));
}
public IQueryable <Book> GetBooks(BooksResourceParameters parameters)
{
return(_context.Books
.Include(b => b.Cover)
.Include(b => b.BookTags)
.ThenInclude(bt => bt.Tag)
.FilterBooks(parameters)
.FilterBooksByTags(parameters.Tags)
.ApplySort(parameters.OrderBy, _propertyMappingService.GetPropertyMapping <BookDto, Book>()));
}
public async Task <IActionResult> GetBooksForAuthor(long authorId,
[FromQuery] BooksResourceParameters booksResourceParameters)
{
if (!_propertyCheckerService.TypeHasProperties <BookDto>(booksResourceParameters.Fields))
{
return(BadRequest($"No field with the name {booksResourceParameters.Fields} was found."));
}
var author = await _messages.Dispatch(new GetAuthorQuery(authorId));
if (author is null)
{
return(NotFound($"No author with id {authorId} was found."));
}
var books = await _messages.Dispatch(new GetBooksListQuery(authorId,
booksResourceParameters.SearchTitle, booksResourceParameters.PageNumber,
booksResourceParameters.PageSize));
var paginationMetadata = new
{
totalCount = books.TotalCount,
pageSize = books.PageSize,
currentPage = books.CurrentPage,
totalPages = books.TotalPages
};
Response.Headers.Add("X-Pagination", JsonSerializer.Serialize(paginationMetadata));
var links = CreateLinksForBooks(booksResourceParameters, books.HasNext, books.HasPrevious);
var shapedBooks = _mapper.Map <IEnumerable <BookDto> >(books)
.ShapeData(booksResourceParameters.Fields);
var shapedBooksWithLinks = shapedBooks.Select(book =>
{
var bookAsDictionary = book as IDictionary <string, object>;
var bookLinks = CreateLinksForBook((long)bookAsDictionary["AuthorId"], (long)bookAsDictionary["Id"], null);
bookAsDictionary.Add("links", bookLinks);
return(bookAsDictionary);
});
var linkedCollectionResource = new
{
value = shapedBooksWithLinks,
links
};
return(Ok(linkedCollectionResource));
}
public static IQueryable <Book> FilterBooks(this IQueryable <Book> source, BooksResourceParameters parameters)
{
source = source.Where(b => b.IsDeleted == parameters.Deleted);
if (parameters.SentKindle.HasValue)
{
source = source.Where(b => b.IsSentToKindle == parameters.SentKindle.Value);
}
if (parameters.IsPublic.HasValue)
{
source = source.Where(b => b.IsPublic == parameters.IsPublic.Value);
}
return(source);
}
public PagedList <Book> GetBooks(BooksResourceParameters booksResourceParameters)
{
var collectionBeforePaging = _context.Books
.OrderBy(b => b.Title)
.AsQueryable();
if (!string.IsNullOrEmpty(booksResourceParameters.BookType))
{
var bookTypeForWhereClause = booksResourceParameters.BookType
.Trim().ToLowerInvariant();
collectionBeforePaging = collectionBeforePaging
.Where(b => b.BookTypeTypeName.ToLowerInvariant() == bookTypeForWhereClause);
}
if (!string.IsNullOrEmpty(booksResourceParameters.Title))
{
var bookTitleForWhereClause = booksResourceParameters.Title
.Trim().ToLowerInvariant();
collectionBeforePaging = collectionBeforePaging
.Where(b => b.Title.Replace(" ", "").ToLowerInvariant() == bookTitleForWhereClause);
}
if (!string.IsNullOrEmpty(booksResourceParameters.Publisher))
{
var bookPublisherForWhereClause = booksResourceParameters.Publisher
.Trim().ToLowerInvariant();
collectionBeforePaging = collectionBeforePaging
.Where(b => b.PublisherPublisherName.Replace(" ", "").ToLowerInvariant() ==
bookPublisherForWhereClause);
}
if (!string.IsNullOrEmpty(booksResourceParameters.SearchQuery))
{
var searchQueryForWhereClause = booksResourceParameters.SearchQuery
.Trim().ToLowerInvariant();
collectionBeforePaging = collectionBeforePaging
.Where(b => b.Title.ToLowerInvariant().Contains(searchQueryForWhereClause) ||
b.BookTypeTypeName.ToLowerInvariant().Contains(searchQueryForWhereClause) ||
b.PublisherPublisherName.ToLowerInvariant().Contains(searchQueryForWhereClause))
.OrderBy(b => b.Title)
.ThenBy(b => b.BookTypeTypeName)
.ThenBy(b => b.PublisherPublisherName);
}
return(PagedList <Book> .Create(collectionBeforePaging,
booksResourceParameters.PageNumber,
booksResourceParameters.PageSize));
}
private string CreateBooksResourceUri(
BooksResourceParameters booksResourceParameters,
ResourceUriType type)
{
switch (type)
{
case ResourceUriType.PreviousPage:
return(_urlHelper.Link("GetBooks",
new
{
searchQuery = booksResourceParameters.SearchQuery,
publisher = booksResourceParameters.Publisher,
title = booksResourceParameters.Title,
bookType = booksResourceParameters.BookType,
pageNumber = booksResourceParameters.PageNumber - 1,
pageSize = booksResourceParameters.PageSize
}));
case ResourceUriType.NextPage:
return(_urlHelper.Link("GetBooks",
new
{
searchQuery = booksResourceParameters.SearchQuery,
publisher = booksResourceParameters.Publisher,
title = booksResourceParameters.Title,
bookType = booksResourceParameters.BookType,
pageNumber = booksResourceParameters.PageNumber + 1,
pageSize = booksResourceParameters.PageSize
}));
default:
return(_urlHelper.Link("GetBooks",
new
{
searchQuery = booksResourceParameters.SearchQuery,
publisher = booksResourceParameters.Publisher,
title = booksResourceParameters.Title,
bookType = booksResourceParameters.BookType,
pageNumber = booksResourceParameters.PageNumber,
pageSize = booksResourceParameters.PageSize
}));
}
}
private string CreateBooksResourceUri(
BooksResourceParameters booksResourceParameters,
ResourceUriType type)
{
switch (type)
{
case ResourceUriType.PreviousPage:
return(Url.Link("GetBooks",
new
{
fields = booksResourceParameters.Fields,
orderBy = booksResourceParameters.OrderBy,
pageNumber = booksResourceParameters.PageNumber - 1,
pageSize = booksResourceParameters.PageSize,
title = booksResourceParameters.Title,
searchQuery = booksResourceParameters.SearchQuery
}));
case ResourceUriType.NextPage:
return(Url.Link("GetBooks",
new
{
fields = booksResourceParameters.Fields,
orderBy = booksResourceParameters.OrderBy,
pageNumber = booksResourceParameters.PageNumber + 1,
pageSize = booksResourceParameters.PageSize,
title = booksResourceParameters.Title,
searchQuery = booksResourceParameters.SearchQuery
}));
default:
return(Url.Link("GetBooks",
new
{
fields = booksResourceParameters.Fields,
orderBy = booksResourceParameters.OrderBy,
pageNumber = booksResourceParameters.PageNumber,
pageSize = booksResourceParameters.PageSize,
title = booksResourceParameters.Title,
searchQuery = booksResourceParameters.SearchQuery
}));
}
}
public async Task <PagedList <Book> > GetBooksForAuthorAsync(Guid authorId, BooksResourceParameters booksResourceParameters)
{
if (booksResourceParameters == null)
{
throw new ArgumentNullException(nameof(booksResourceParameters));
}
if (authorId == null)
{
throw new ArgumentNullException(nameof(authorId));
}
var collection = _context.Books as IQueryable <Book>;
// get property mapping dictionary
var bookPropertyMappingDictionary =
_propertyMappingService.GetPropertyMapping <BookDto, Book>();
// Apply Searching ..
if (!string.IsNullOrWhiteSpace(booksResourceParameters.SearchQuery))
{
var searchQuery = booksResourceParameters.SearchQuery.Trim();
collection = collection.Include(b => b.Author)
.Include(b => b.Publisher)
.Include(b => b.BookCategories)
.Where(b => b.Description.Contains(searchQuery) ||
b.ISBN.Contains(searchQuery) ||
b.Publisher.Name.Contains(searchQuery) ||
b.Author.FirstName.Contains(searchQuery) ||
b.Author.LastName.Contains(searchQuery) ||
b.Title.Contains(searchQuery) ||
b.BookCategories.Select(bc => bc.Category.Name).Contains(searchQuery));
}
var finalCollectopn = collection.Include(c => c.Author)
.Include(c => c.Publisher)
.Include(c => c.BookCategories);
return(await PagedList <Book> .Create(finalCollectopn,
booksResourceParameters.PageNumber,
booksResourceParameters.PageSize));
}
public IActionResult GetBooks(
[FromQuery] BooksResourceParameters booksResourceParameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <BookDto, Book>
(booksResourceParameters.OrderBy))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <BookDto>
(booksResourceParameters.Fields))
{
return(BadRequest());
}
var booksFromRepo = _repositoryWrapper.Books.GetBooks(booksResourceParameters);
var previousPageLink = booksFromRepo.HasPrevious ?
CreateBooksResourceUri(booksResourceParameters,
ResourceUriType.PreviousPage) : null;
var nextPageLink = booksFromRepo.HasNext ?
CreateBooksResourceUri(booksResourceParameters,
ResourceUriType.NextPage) : null;
var paginationMetadata = new
{
totalCount = booksFromRepo.TotalCount,
pageSize = booksFromRepo.PageSize,
currentPage = booksFromRepo.CurrentPage,
totalPages = booksFromRepo.TotalPages,
previousPageLink,
nextPageLink
};
Response.Headers.Add("X-Pagination",
JsonSerializer.Serialize(paginationMetadata));
return(Ok(_mapper.Map <IEnumerable <BookDto> >(booksFromRepo)
.ShapeData(booksResourceParameters.Fields)));
}
public PagedList <Book> GetBooks(BooksResourceParameters booksResourceParameters)
{
if (booksResourceParameters == null)
{
throw new ArgumentNullException(nameof(booksResourceParameters));
}
var collectionOfBooks = ApplicationDbContext.Books
.Include(a => a.BookAuthors)
.ThenInclude(ba => ba.Author) as IQueryable <Book>;
if (!string.IsNullOrWhiteSpace(booksResourceParameters.Title))
{
var title = booksResourceParameters.Title.Trim();
collectionOfBooks = collectionOfBooks.Where(book => book.Title == title);
}
if (!string.IsNullOrWhiteSpace(booksResourceParameters.SearchQuery))
{
var searchQuery = booksResourceParameters.SearchQuery.Trim();
collectionOfBooks = collectionOfBooks.Where(book => book.Title.Contains(searchQuery) ||
book.Description.Contains(searchQuery) ||
book.Publisher.Contains(searchQuery)
);
}
if (!string.IsNullOrWhiteSpace(booksResourceParameters.OrderBy))
{
var bookPropertyMappingDictionary =
_propertyMappingService.GetPropertyMapping <BookDto, Book>();
collectionOfBooks = collectionOfBooks.ApplySort(booksResourceParameters.OrderBy,
bookPropertyMappingDictionary);
}
return(PagedList <Book> .Create(collectionOfBooks,
booksResourceParameters.PageNumber,
booksResourceParameters.PageSize));
}
