public async Task <Result <PagedList <DiscountListItemModel> > > GetDiscounts([FromBody] DiscountFilter filter)
{
var result = await _discountService.GetDiscountsAsync(filter);
var toReturn = new PagedList <DiscountListItemModel>
{
Items = result.Items.Select(p => new DiscountListItemModel(p)).ToList(),
Count = result.Count,
};
foreach (var discountListItemModel in toReturn.Items)
{
discountListItemModel.DiscountTypeName =
LookupHelper.GetDiscountTypeName(discountListItemModel.DiscountType);
}
return(toReturn);
}
// Function chain
public static IEnumerable <InventoryItem> GetItemsForDiscountWithoutExtensions(this IEnumerable <InventoryItemStore> inventoryList, DiscountFilter filter)
{
return(inventoryList
.Where(r => r.InventoryItem.EnabledForSale)
.Where(r => r.InventoryItem.IsNextToExpire(filter.GetMinExpirationDate(r.InventoryItem.DaysToSellBeforeExpire)))
.Where(r => r.ExistsStock)
.Select(r => r.InventoryItem));
}
// Function chain
//// Extensions don't define behavior in a OOP
//// Extensions define behavior in a Functional programming but C# is OOP
public static IEnumerable <InventoryItem> GetItemsForDiscount(this IEnumerable <InventoryItemStore> inventoryList, DiscountFilter filter)
{
return(inventoryList
.GetEnabledsForSale()
.GetInStock()
.GetNextToExpire(filter.GetMinExpirationDate)
.Select(r => r.InventoryItem));
}
private IQueryable <DiscountDAO> DynamicOrder(IQueryable <DiscountDAO> query, DiscountFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case DiscountOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case DiscountOrder.Name:
query = query.OrderBy(q => q.Name);
break;
case DiscountOrder.Start:
query = query.OrderBy(q => q.Start);
break;
case DiscountOrder.End:
query = query.OrderBy(q => q.End);
break;
case DiscountOrder.Type:
query = query.OrderBy(q => q.Type);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case DiscountOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case DiscountOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
case DiscountOrder.Start:
query = query.OrderByDescending(q => q.Start);
break;
case DiscountOrder.End:
query = query.OrderByDescending(q => q.End);
break;
case DiscountOrder.Type:
query = query.OrderByDescending(q => q.Type);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
private IQueryable <DiscountDAO> DynamicFilter(IQueryable <DiscountDAO> query, DiscountFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
if (filter.Id != null)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.Name != null)
{
query = query.Where(q => q.Name, filter.Name);
}
if (filter.Start != null)
{
query = query.Where(q => q.Start, filter.Start);
}
if (filter.End != null)
{
query = query.Where(q => q.End, filter.End);
}
if (filter.Type != null)
{
query = query.Where(q => q.Type, filter.Type);
}
if (filter.Ids != null)
{
query = query.Where(q => filter.Ids.Contains(q.Id));
}
if (filter.ExceptIds != null)
{
query = query.Where(q => !filter.ExceptIds.Contains(q.Id));
}
return(query);
}
private async Task <List <Discount> > DynamicSelect(IQueryable <DiscountDAO> query, DiscountFilter filter)
{
List <Discount> Discounts = await query.Select(q => new Discount()
{
Id = filter.Selects.Contains(DiscountSelect.Id) ? q.Id : default(long),
Name = filter.Selects.Contains(DiscountSelect.Name) ? q.Name : default(string),
Start = filter.Selects.Contains(DiscountSelect.Start) ? q.Start : default(DateTime),
End = filter.Selects.Contains(DiscountSelect.End) ? q.End : default(DateTime),
Type = filter.Selects.Contains(DiscountSelect.Type) ? q.Type : default(string),
}).ToListAsync();
return(Discounts);
}
public async Task <List <Discount> > List(DiscountFilter DiscountFilter)
{
List <Discount> Discounts = await UOW.DiscountRepository.List(DiscountFilter);
return(Discounts);
}
public async Task <int> Count(DiscountFilter DiscountFilter)
{
int result = await UOW.DiscountRepository.Count(DiscountFilter);
return(result);
}
