public async Task <IEnumerable <AuctionDto> > Query(string sort = null, bool asc = true, string name = null,
decimal minimalActualPrice = 0m, decimal maximalActualtPrice = decimal.MaxValue,
DateTime?minimalEndTime = null, DateTime?maximalEndTime = null, [FromUri] string[] category = null)
{
if (minimalEndTime == null)
{
minimalEndTime = DateTime.MinValue;
}
if (maximalEndTime == null)
{
maximalEndTime = DateTime.MaxValue;
}
var filter = new AuctionFilterDto
{
SortCriteria = sort,
SortAscending = asc,
SearchedName = name,
MinimalEndTime = minimalEndTime.Value,
MaximalEndTime = maximalEndTime.Value,
MaximalActualPrice = maximalActualtPrice,
MinimalActualPrice = minimalActualPrice
};
var auctions = (await AuctionProcessFacade.GetAuctionsAsync(filter)).Items;
SafeSetEntityId(auctions);
return(auctions);
}
protected override IQuery <Auction> ApplyWhereClause(IQuery <Auction> query, AuctionFilterDto filter)
{
var definedPredicates = new List <IPredicate>();
AddIfDefined(FilterItemName(filter), definedPredicates);
AddIfDefined(FilterSeller(filter), definedPredicates);
AddIfDefined(FilterCategories(filter), definedPredicates);
AddIfDefined(FilterOnlyActive(filter), definedPredicates);
AddIfDefined(FilterMaximalPrice(filter), definedPredicates);
AddIfDefined(FilterMinimalPrice(filter), definedPredicates);
AddIfDefined(FilterMinimalEndTime(filter), definedPredicates);
AddIfDefined(FilterMaximalEndTime(filter), definedPredicates);
if (definedPredicates.Count == 0)
{
return(query);
}
if (definedPredicates.Count == 1)
{
return(query.Where(definedPredicates.First()));
}
var resultPredicate = new CompositePredicate(definedPredicates);
return(query.Where(resultPredicate));
}
private static SimplePredicate FilterActualPrice(AuctionFilterDto filter)
{
if (filter.ActualPrice < 0 || filter.ActualPrice == decimal.MaxValue)
{
return(null);
}
return(new SimplePredicate(nameof(Auction.ActualPrice), ValueComparingOperator.Equal, filter.ActualPrice));
}
private static SimplePredicate FilterAccountId(AuctionFilterDto filter)
{
if (filter.AccountId.Equals(Guid.Empty))
{
return(null);
}
return(new SimplePredicate(nameof(Auction.AccountId), ValueComparingOperator.Equal, filter.AccountId));
}
private static SimplePredicate FilterClosingTime(AuctionFilterDto filter)
{
if (filter.ClosingTime < DateTime.Now)
{
return(null);
}
return(new SimplePredicate(nameof(Auction.ClosingTime), ValueComparingOperator.Equal, filter.ClosingTime));
}
private static SimplePredicate FilterName(AuctionFilterDto filter)
{
if (string.IsNullOrWhiteSpace(filter.Name))
{
return(null);
}
return(new SimplePredicate(nameof(Auction.Name), ValueComparingOperator.Equal, filter.Name));
}
private static SimplePredicate FilterAuctionNames(AuctionFilterDto filter)
{
if (string.IsNullOrWhiteSpace(filter.AuctionSearchedName))
{
return(null);
}
return(new SimplePredicate(nameof(Auction.Name), ValueComparingOperator.StringContains, filter.AuctionSearchedName));
}
private static SimplePredicate FilterMaximalEndTime(AuctionFilterDto filter)
{
if (filter.MaximalEndTime == DateTime.MaxValue)
{
return(null);
}
return(new SimplePredicate(nameof(Auction.EndTime), ValueComparingOperator.LessThanOrEqual,
filter.MaximalEndTime));
}
private static SimplePredicate FilterMinimalPrice(AuctionFilterDto filter)
{
if (filter.MinimalActualPrice == decimal.MinValue)
{
return(null);
}
return(new SimplePredicate(nameof(Auction.ActualPrice), ValueComparingOperator.GreaterThanOrEqual,
filter.MinimalActualPrice));
}
private static CompositePredicate FilterCategories(AuctionFilterDto filter)
{
if (filter.CategoryIds == null || filter.CategoryIds.Any())
{
return(null);
}
var predicates = new List <IPredicate>(filter.CategoryIds
.Select(categoryId =>
new SimplePredicate(nameof(Auction.CategoryId), ValueComparingOperator.Equal, categoryId)));
return(new CompositePredicate(predicates, LogicalOperator.OR));
}
private static IPredicate FilterAuctionDate(AuctionFilterDto filter)
{
if (filter.ActualDateTime == DateTime.MaxValue)
{
return(null);
}
return(new CompositePredicate(new List <IPredicate>
{
new SimplePredicate(nameof(Auction.EndDate), ValueComparingOperator.GreaterThan, filter.ActualDateTime),
new SimplePredicate(nameof(Auction.EndDate), ValueComparingOperator.GreaterThan, filter.ActualDateTime)
}));
}
public async Task <IEnumerable <AuctionDTO> > Query(string sort = null, bool asc = true, [FromUri] string[] category = null)
{
var filter = new AuctionFilterDto
{
SortCriteria = sort,
SortAscending = asc,
CategoryNames = category,
};
var auctions = (await AuctionFacade.GetAllAuctionsAsync(filter));
foreach (var auction in auctions.Items)
{
auction.Id = Guid.Empty;
}
return(auctions.Items);
}
public async Task <IEnumerable <AuctionDto> > GetAuctionQuery(string sort = null, bool asc = true,
string name = null, int minPrice = 0, int maxPrice = int.MaxValue,
[FromUri] CategoryDto[] categories = null)
{
var filter = new AuctionFilterDto()
{
SortCriteria = sort,
SortAscending = asc,
AuctionSearchedName = name,
MinimalPrice = minPrice,
MaximalPrice = maxPrice,
AuctionerID = 0
};
var auctions = (await AuctionFacade.GetFilteredAuctionsAsync(filter)).Items;
foreach (var auction in auctions)
{
auction.Id = 0;
}
return(auctions);
}
protected override IQuery <Auction> ApplyWhereClause(IQuery <Auction> query, AuctionFilterDto filter)
{
var definedPredicates = new List <IPredicate>();
AddIfDefined(FilterCategories(filter), definedPredicates);
AddIfDefined(FilterName(filter), definedPredicates);
AddIfDefined(FilterAccountId(filter), definedPredicates);
AddIfDefined(FilterClosingTime(filter), definedPredicates);
//AddIfDefined(FilterActualPrice(filter), definedPredicates);
if (definedPredicates.Count == 0)
{
return(query);
}
if (definedPredicates.Count == 1)
{
return(query.Where(definedPredicates.First()));
}
var predicate = new CompositePredicate(definedPredicates);
return(query.Where(predicate));
}
protected override IQuery <Auction> ApplyWhereClause(IQuery <Auction> query, AuctionFilterDto filter)
{
var definedPredicates = new List <IPredicate>();
AddIfDefined(FilterAuctionNames(filter), definedPredicates);
AddIfDefined(FilterAuctionPrices(filter), definedPredicates);
AddIfDefined(FilterAuctionDate(filter), definedPredicates);
AddIfDefined(FilterAuctioner(filter), definedPredicates);
if (definedPredicates.Count == 0)
{
return(query);
}
if (definedPredicates.Count == 1)
{
return(query.Where(definedPredicates.First()));
}
var whereŠtokPredicate = new CompositePredicate(definedPredicates);
return(query.Where(whereŠtokPredicate));
}
private static IPredicate FilterAuctionPrices(AuctionFilterDto filter)
{
if (filter.MinimalPrice <= 0 && filter.MaximalPrice == double.MaxValue)
{
return(null);
}
if (filter.MinimalPrice > 0 && filter.MaximalPrice < double.MaxValue)
{
return(new CompositePredicate(new List <IPredicate>
{
new SimplePredicate(nameof(Auction.ActualPrice), ValueComparingOperator.GreaterThanOrEqual, filter.MinimalPrice),
new SimplePredicate(nameof(Auction.ActualPrice), ValueComparingOperator.LessThanOrEqual, filter.MaximalPrice)
}));
}
if (filter.MinimalPrice > 0)
{
return(new SimplePredicate(nameof(Auction.ActualPrice), ValueComparingOperator.GreaterThan, filter.MinimalPrice));
}
return(new SimplePredicate(nameof(Auction.ActualPrice), ValueComparingOperator.LessThanOrEqual,
filter.MaximalPrice));
}
public async Task <QueryResultDto <AuctionDto, AuctionFilterDto> > GetFilteredAuctionsAsync(AuctionFilterDto filter)
{
using (UnitOfWorkProvider.Create())
{
if (filter == null)
{
return(await auctionService.ListAllAsync());
}
return(await auctionService.ListFilteredAuctions(filter));
}
}
private static SimplePredicate FilterOnlyActive(AuctionFilterDto filter)
{
return(!filter.OnlyActive
? null
: new SimplePredicate(nameof(Auction.Ended), ValueComparingOperator.Equal, false));
}
public async Task <QueryResultDto <AuctionDTO, AuctionFilterDto> > GetAllAuctionsAsync(AuctionFilterDto filter)
{
using (UnitOfWorkProvider.Create())
{
if (filter.CategoryIds == null && filter.CategoryNames != null)
{
filter.CategoryIds = await categoryService.GetCategoryIdsByNamesAsync(filter.CategoryNames);
}
return(await auctionService.ListAuctionsAsync(filter));
}
}
private static SimplePredicate FilterSeller(AuctionFilterDto filter)
{
return(filter.SellerId.Equals(Guid.Empty)
? null
: new SimplePredicate(nameof(Auction.SellerId), ValueComparingOperator.Equal, filter.SellerId));
}
private static SimplePredicate FilterItemName(AuctionFilterDto filter)
{
return(string.IsNullOrWhiteSpace(filter.SearchedName)
? null
: new SimplePredicate(nameof(Auction.Name), ValueComparingOperator.StringContains, filter.SearchedName));
}
public async Task <QueryResultDto <AuctionDto, AuctionFilterDto> > GetAuctionsAsync(AuctionFilterDto filter)
{
using (UnitOfWorkProvider.Create())
{
return(await _auctionService.ListAuctionsAsync(filter));
}
}
private static IPredicate FilterAuctioner(AuctionFilterDto filter)
{
return(filter.AuctionerID == 0 ? null
: new SimplePredicate(nameof(Auction.UserId), ValueComparingOperator.Equal, filter.AuctionerID));
}
