public async Task <int> Count(DiscountContentFilter filter)
{
IQueryable <DiscountContentDAO> DiscountContentDAOs = DataContext.DiscountContent;
DiscountContentDAOs = DynamicFilter(DiscountContentDAOs, filter);
return(await DiscountContentDAOs.CountAsync());
}
public async Task <int> Count([FromBody] DiscountContentMaster_DiscountContentFilterDTO DiscountContentMaster_DiscountContentFilterDTO)
{
if (!ModelState.IsValid)
{
throw new MessageException(ModelState);
}
DiscountContentFilter DiscountContentFilter = ConvertFilterDTOToFilterEntity(DiscountContentMaster_DiscountContentFilterDTO);
return(await DiscountContentService.Count(DiscountContentFilter));
}
public async Task <List <DiscountContentMaster_DiscountContentDTO> > List([FromBody] DiscountContentMaster_DiscountContentFilterDTO DiscountContentMaster_DiscountContentFilterDTO)
{
if (!ModelState.IsValid)
{
throw new MessageException(ModelState);
}
DiscountContentFilter DiscountContentFilter = ConvertFilterDTOToFilterEntity(DiscountContentMaster_DiscountContentFilterDTO);
List <DiscountContent> DiscountContents = await DiscountContentService.List(DiscountContentFilter);
return(DiscountContents.Select(c => new DiscountContentMaster_DiscountContentDTO(c)).ToList());
}
public async Task <List <DiscountContent> > List(DiscountContentFilter filter)
{
if (filter == null)
{
return(new List <DiscountContent>());
}
IQueryable <DiscountContentDAO> DiscountContentDAOs = DataContext.DiscountContent;
DiscountContentDAOs = DynamicFilter(DiscountContentDAOs, filter);
DiscountContentDAOs = DynamicOrder(DiscountContentDAOs, filter);
var DiscountContents = await DynamicSelect(DiscountContentDAOs, filter);
return(DiscountContents);
}
public DiscountContentFilter ConvertFilterDTOToFilterEntity(DiscountContentMaster_DiscountContentFilterDTO DiscountContentMaster_DiscountContentFilterDTO)
{
DiscountContentFilter DiscountContentFilter = new DiscountContentFilter();
DiscountContentFilter.Selects = DiscountContentSelect.ALL;
DiscountContentFilter.Id = new LongFilter {
Equal = DiscountContentMaster_DiscountContentFilterDTO.Id
};
DiscountContentFilter.ItemId = new LongFilter {
Equal = DiscountContentMaster_DiscountContentFilterDTO.ItemId
};
DiscountContentFilter.DiscountValue = new LongFilter {
Equal = DiscountContentMaster_DiscountContentFilterDTO.DiscountValue
};
DiscountContentFilter.DiscountId = new LongFilter {
Equal = DiscountContentMaster_DiscountContentFilterDTO.DiscountId
};
return(DiscountContentFilter);
}
public async Task <bool> ValidateId(DiscountContent DiscountContent)
{
DiscountContentFilter DiscountContentFilter = new DiscountContentFilter
{
Skip = 0,
Take = 10,
Id = new LongFilter {
Equal = DiscountContent.Id
},
Selects = DiscountContentSelect.Id
};
int count = await UOW.DiscountContentRepository.Count(DiscountContentFilter);
if (count == 0)
{
DiscountContent.AddError(nameof(DiscountContentValidator), nameof(DiscountContent.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
private IQueryable <DiscountContentDAO> DynamicOrder(IQueryable <DiscountContentDAO> query, DiscountContentFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case DiscountContentOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case DiscountContentOrder.Item:
query = query.OrderBy(q => q.Item.Id);
break;
case DiscountContentOrder.DiscountValue:
query = query.OrderBy(q => q.DiscountValue);
break;
case DiscountContentOrder.Discount:
query = query.OrderBy(q => q.Discount.Id);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case DiscountContentOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case DiscountContentOrder.Item:
query = query.OrderByDescending(q => q.Item.Id);
break;
case DiscountContentOrder.DiscountValue:
query = query.OrderByDescending(q => q.DiscountValue);
break;
case DiscountContentOrder.Discount:
query = query.OrderByDescending(q => q.Discount.Id);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
private IQueryable <DiscountContentDAO> DynamicFilter(IQueryable <DiscountContentDAO> query, DiscountContentFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
if (filter.Id != null)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.ItemId != null)
{
query = query.Where(q => q.ItemId, filter.ItemId);
}
if (filter.DiscountValue != null)
{
query = query.Where(q => q.DiscountValue, filter.DiscountValue);
}
if (filter.DiscountId != null)
{
query = query.Where(q => q.DiscountId, filter.DiscountId);
}
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 <DiscountContent> > DynamicSelect(IQueryable <DiscountContentDAO> query, DiscountContentFilter filter)
{
List <DiscountContent> DiscountContents = await query.Select(q => new DiscountContent()
{
Id = filter.Selects.Contains(DiscountContentSelect.Id) ? q.Id : default(long),
ItemId = filter.Selects.Contains(DiscountContentSelect.Item) ? q.ItemId : default(long),
DiscountValue = filter.Selects.Contains(DiscountContentSelect.DiscountValue) ? q.DiscountValue : default(long),
DiscountId = filter.Selects.Contains(DiscountContentSelect.Discount) ? q.DiscountId : default(long),
Discount = filter.Selects.Contains(DiscountContentSelect.Discount) && q.Discount != null ? new Discount
{
Id = q.Discount.Id,
Name = q.Discount.Name,
Start = q.Discount.Start,
End = q.Discount.End,
Type = q.Discount.Type,
} : null,
Item = filter.Selects.Contains(DiscountContentSelect.Item) && q.Item != null ? new Item
{
Id = q.Item.Id,
ProductId = q.Item.ProductId,
FirstVariationId = q.Item.FirstVariationId,
SecondVariationId = q.Item.SecondVariationId,
SKU = q.Item.SKU,
Price = q.Item.Price,
MinPrice = q.Item.MinPrice,
} : null,
}).ToListAsync();
return(DiscountContents);
}
public async Task <List <DiscountContent> > List(DiscountContentFilter DiscountContentFilter)
{
List <DiscountContent> DiscountContents = await UOW.DiscountContentRepository.List(DiscountContentFilter);
return(DiscountContents);
}
public async Task <int> Count(DiscountContentFilter DiscountContentFilter)
{
int result = await UOW.DiscountContentRepository.Count(DiscountContentFilter);
return(result);
}
