private Func <IQueryable <Book>, IOrderedQueryable <Book> > GetOrderBy(BookOrderBy orderBy, bool orderDesc)
{
switch (orderBy)
{
case BookOrderBy.BookId:
return(query => !orderDesc?query.OrderBy(b => b.BookId) : query.OrderByDescending(b => b.BookId));
case BookOrderBy.BookTitle:
default:
return(query => !orderDesc?query.OrderBy(b => b.Title) : query.OrderByDescending(b => b.Title));
}
}
public List <Book> SearchBooks(
out int totalCount,
int pageSize,
int pageNum,
int[] author,
int[] protagonist,
int[] country,
BookOrderBy orderBy = BookOrderBy.BookTitle,
bool?orderDesc = default(bool?))
{
// included entities
var includedEntities = new List <Expression <Func <Book, object> > >
{
b => b.Authors.Select(a => a.Country),
b => b.Protagonists
};
// search filters
var searchCriteria = new List <Expression <Func <Book, bool> > >();
if (author != null && author.Any() && author.All(p => p > 0))
{
searchCriteria.Add(b => author.Any(a => b.Authors.Any(a2 => a2.AuthorId == a)));
}
if (protagonist != null && protagonist.Any() && protagonist.All(p => p > 0))
{
searchCriteria.Add(b => protagonist.Any(p => b.Protagonists.Any(p2 => p2.ProtagonistId == p)));
}
if (country != null && country.Any() && country.All(p => p > 0))
{
searchCriteria.Add(b => country.Any(c => b.Authors.Any(a => a.CountryId == c)));
}
// order by
Func <IQueryable <Book>, IOrderedQueryable <Book> > orderByFunc = GetOrderBy(orderBy, orderDesc.GetValueOrDefault());
var bookSearchQuery = this._repo.Get(searchCriteria, orderByFunc, includedEntities);
totalCount = bookSearchQuery.Count();
bookSearchQuery = bookSearchQuery.Skip(pageNum * pageSize).Take(pageSize);
return(bookSearchQuery.AsNoTracking().ToList());
}
public static IQueryable <BookListDto> OrderBy(
this IQueryable <BookListDto> books, BookOrderBy orderBy)
{
switch (orderBy)
{
case BookOrderBy.SimpleOrder:
return(books.OrderByDescending(b => b.BookId));
case BookOrderBy.ByVotes:
return(books.OrderByDescending(b => b.ReviewsAverageVotes));
case BookOrderBy.ByPublicationDate:
return(books.OrderByDescending(b => b.PublishedOn));
case BookOrderBy.ByPriceLowestFirst:
return(books.OrderBy(b => b.Price));
case BookOrderBy.ByPriceHigestFirst:
return(books.OrderByDescending(b => b.Price));
default: throw new ArgumentOutOfRangeException(nameof(orderBy), orderBy, null);
}
}
public IEnumerable<Book> GetBooks(out int totalRecords, string titleFilter, int? limitOffset, int? limitRowCount, BookOrderBy? orderBy, bool desc)
{
List<Book> results = new List<Book>();
using (var db = new Data.MVCGridDemoEntities())
{
var query = db.Books.AsQueryable();
if (!String.IsNullOrWhiteSpace(titleFilter))
{
query = query.Where(p => p.Title.Contains(titleFilter));
}
//if (!String.IsNullOrWhiteSpace(filterLastName))
//{
// query = query.Where(p => p.LastName.Contains(filterLastName));
//}
//if (filterActive.HasValue)
//{
// query = query.Where(p => p.Active == filterActive.Value);
//}
//if (!String.IsNullOrWhiteSpace(globalSearch))
//{
// query = query.Where(p => (p.FirstName + " " + p.LastName).Contains(globalSearch));
//}
totalRecords = query.Count();
if (orderBy.HasValue)
{
switch (orderBy.Value)
{
case BookOrderBy.Author:
if (!desc)
query = query.OrderBy(p => p.Author);
else
query = query.OrderByDescending(p => p.Author);
break;
case BookOrderBy.BindingTypeId:
if (!desc)
query = query.OrderBy(p => p.BindingTypeId);
else
query = query.OrderByDescending(p => p.BindingTypeId);
break;
case BookOrderBy.Imprint:
if (!desc)
query = query.OrderBy(p => p.Imprint);
else
query = query.OrderByDescending(p => p.Imprint);
break;
case BookOrderBy.Index:
if (!desc)
query = query.OrderBy(p => p.Index);
else
query = query.OrderByDescending(p => p.Index);
break;
case BookOrderBy.ISBN:
if (!desc)
query = query.OrderBy(p => p.ISBN);
else
query = query.OrderByDescending(p => p.ISBN);
break;
case BookOrderBy.Position:
if (!desc)
query = query.OrderBy(p => p.Position);
else
query = query.OrderByDescending(p => p.Position);
break;
case BookOrderBy.PublicationDate:
if (!desc)
query = query.OrderBy(p => p.PublDate);
else
query = query.OrderByDescending(p => p.PublDate);
break;
case BookOrderBy.PublisherGroup:
if (!desc)
query = query.OrderBy(p => p.PublisherGroup);
else
query = query.OrderByDescending(p => p.PublisherGroup);
break;
case BookOrderBy.Title:
if (!desc)
query = query.OrderBy(p => p.Title);
else
query = query.OrderByDescending(p => p.Title);
break;
case BookOrderBy.Volume:
if (!desc)
query = query.OrderBy(p => p.Volume);
else
query = query.OrderByDescending(p => p.Volume);
break;
}
}
if (limitOffset.HasValue)
{
query = query.Skip(limitOffset.Value).Take(limitRowCount.Value);
}
foreach (var dbBook in query)
{
Book book = new Book()
{
Author = dbBook.Author,
BindingTypeId = dbBook.BindingTypeId.Value,
Imprint = dbBook.Imprint,
Index = dbBook.Index,
ISBN = dbBook.ISBN,
Position = dbBook.Position.Value,
PublicationDate = dbBook.PublDate.Value,
PublisherGroup = dbBook.PublisherGroup,
Title = dbBook.Title,
Volume = dbBook.Volume.Value
};
results.Add(book);
}
}
return results;
}
public IEnumerable<Book> GetBooks(out int totalRecords, int? limitOffset, int? limitRowCount, BookOrderBy? orderBy, bool desc)
{
return GetBooks(out totalRecords, null, limitOffset, limitRowCount, orderBy, desc);
}
