public Expression <Func <Contract, bool> > ComposeFilter(ContractFilterCriteria gameFilterCriteria)
{
Expression <Func <Contract, bool> > expression = contract => contract.Status == Status.Approved;
if (gameFilterCriteria.EditionName != null)
{
expression = new NameFilter().AddFilter(gameFilterCriteria, expression);
}
if (gameFilterCriteria.Genres != null && gameFilterCriteria.Genres.Count != 0)
{
expression = new GenresFilter().AddFilter(gameFilterCriteria, expression);
}
if (gameFilterCriteria.Publishers != null && gameFilterCriteria.Publishers.Count != 0)
{
expression = new PublishersFilter().AddFilter(gameFilterCriteria, expression);
}
if (gameFilterCriteria.Periodicities != null && gameFilterCriteria.Periodicities.Count != 0)
{
expression = new PeriodicityFilter().AddFilter(gameFilterCriteria, expression);
}
return(expression);
}
private void IgnoreIfNameIsWhiteSpace(ContractFilterCriteria contractFilterCriteria)
{
if (contractFilterCriteria?.EditionName == null)
{
return;
}
if (contractFilterCriteria.EditionName.Trim() == string.Empty)
{
contractFilterCriteria.EditionName = null;
}
}
public Expression <Func <Contract, bool> > AddFilter(
ContractFilterCriteria model,
Expression <Func <Contract, bool> > existingFilter = null)
{
Expression <Func <Contract, bool> > publishersFilter
= contract => model.Publishers.Contains(contract.Publisher.Name);
if (existingFilter != null)
{
publishersFilter = CombineFilters(existingFilter, publishersFilter);
}
return(publishersFilter);
}
public Expression <Func <Contract, bool> > AddFilter(
ContractFilterCriteria model,
Expression <Func <Contract, bool> > existingFilter = null)
{
Expression <Func <Contract, bool> > genresFilter = contract =>
contract.Genres.Any(g => model.Genres.Contains(g.Name));
if (existingFilter != null)
{
genresFilter = CombineFilters(existingFilter, genresFilter);
}
return(genresFilter);
}
public Expression <Func <Contract, bool> > AddFilter(
ContractFilterCriteria model,
Expression <Func <Contract, bool> > existingFilter = null)
{
Expression <Func <Contract, bool> > periodicityFilter
= contract => model.Periodicities.Contains(contract.Periodicity);
if (existingFilter != null)
{
periodicityFilter = CombineFilters(existingFilter, periodicityFilter);
}
return(periodicityFilter);
}
public IEnumerable <Contract> GetApprovedContractWithEditions(ContractFilterCriteria contractFilterCriteria)
{
var sorting = new ContractSortingResolver().CreateSorting(contractFilterCriteria);
var predicate = new ContractsFilter().ComposeFilter(contractFilterCriteria);
var contracts = _unitOfWork.GetRepository <Contract>()
.GetMany(predicate, sorting, null, null, i => i.Editions, i => i.Publisher, i => i.Genres);
if (contracts != null)
{
contracts = contracts.Where(x => x.Editions.Count > 0);
}
return(contracts);
}
public Expression <Func <Contract, bool> > AddFilter(
ContractFilterCriteria model,
Expression <Func <Contract, bool> > existingFilter = null)
{
if (model.EditionName == null)
{
return(existingFilter);
}
Expression <Func <Contract, bool> > nameFilter
= contract => contract.EditionTitle.Contains(model.EditionName);
if (existingFilter != null)
{
nameFilter = CombineFilters(existingFilter, nameFilter);
}
return(nameFilter);
}
public ActionResult GetContractsForFollowing(ContractFilterCriteria contractFilterCriteria)
{
IgnoreIfNameIsWhiteSpace(contractFilterCriteria);
contractFilterCriteria.SortCriterion =
contractFilterCriteria.SortCriterion == null?
SortCriteria.Rating : contractFilterCriteria.SortCriterion;
var contracts = _contractService.GetApprovedContractWithEditions(contractFilterCriteria);
var contractsShowcaseModel = new List <ContractsShowcase>();
Mapper.Map(contracts, contractsShowcaseModel);
var model = new CatalogViewModel
{
ContractsShowcase = contractsShowcaseModel,
Genres = _genreService.GetAllGenres().Select(x => x.Name).ToList(),
Publishers = _publisherService.GetAllPublishers().Select(x => x.Name).ToList(),
Periodicities = EnumToMultiselectList <Periodicity>()
};
return(View("Catalog", model));
}
public Func <IQueryable <Contract>, IOrderedQueryable <Contract> > CreateSorting(ContractFilterCriteria model)
{
return(model.SortCriterion != null ? _sorts[model.SortCriterion] : null);
}
