public IEnumerable <BrandResponseDTO> Execute(BrandSearch request)
{
var keyword = request.Keyword;
var query = AiContext.Brands
.AsQueryable()
.Where(x => x.IsDeleted == 0);
if (keyword != null)
{
query = query
.Where(x => x.Name.ToLower().Contains(keyword.ToLower()));
}
return(query
.Include(u => u.Vehicles)
.Select(x => new BrandResponseDTO
{
Id = x.Id,
Name = x.Name,
Vehicles = AiContext.Vehicles
.Where(v => v.BrandId == x.Id)
.Select(v => new BrandVehicleResponseDTO
{
Id = v.Id,
Model = v.Model,
CostPerHour = v.CostPerDay,
FuelTankCapacity = v.FuelTankCapacity,
VehicleType = v.VehicleType.Name,
Automatic = v.Automatic,
Rented = v.Rented,
Color = v.Color
})
}));
}
public PagedResponse <BrandDto> Execute(BrandSearch search)
{
var query = _context.Brands.AsQueryable();
if (!string.IsNullOrEmpty(search.Name) || !string.IsNullOrWhiteSpace(search.Name))
{
query = query.Where(x => x.Name.ToLower().Contains(search.Name.ToLower()));
}
var skipCount = search.PerPage * (search.Page - 1);
var response = new PagedResponse <BrandDto>
{
CurrentPage = search.Page,
ItemsPerPage = search.PerPage,
TotalCount = query.Count(),
Items = query.Skip(skipCount).Take(search.PerPage).Select(x => new BrandDto
{
Id = x.Id,
Name = x.Name
}).ToList()
};
return(response);
}
public PageResponse <MarkaDto> Execute(BrandSearch request)
{
var query = Context.Marke.AsQueryable().Skip((request.PageNumber - 1) * request.PerPage).Take(request.PerPage);
var totalRecords = query.Count();
var pagesCount = (int)Math.Ceiling((double)totalRecords / request.PerPage);
if (request != null)
{
if (request.Keyword != null)
{
query = query.Where(m => m.MarkaAutomobila
.ToLower()
.Contains(request.Keyword.ToLower()));
}
totalRecords = query.Count();
var response = new PageResponse <MarkaDto>
{
CurrentPage = request.PageNumber,
TotalCount = totalRecords,
PagesCount = pagesCount,
Data = query.Select(m => new MarkaDto
{
Id = m.Id,
Marka = m.MarkaAutomobila,
DateCreated = m.DateCreated,
DateModified = m.DateModified
})
};
return(response);
}
else
{
return(new PageResponse <MarkaDto>
{
CurrentPage = request.PageNumber,
TotalCount = totalRecords,
PagesCount = pagesCount,
Data = query.Select(m => new MarkaDto
{
Id = m.Id,
Marka = m.MarkaAutomobila,
DateCreated = m.DateCreated,
DateModified = m.DateModified
})
});
}
}
public IActionResult Get([FromQuery] BrandSearch search)
{
try
{
var marke = _getBrandsCommand.Execute(search);
return(Ok(marke));
}
catch (EntityNotFoundException e)
{
if (e.Message == "Marka doesn't exist.")
{
return(NotFound(e.Message));
}
return(UnprocessableEntity(e.Message));
}
}
public async Task <IActionResult> Get(
[FromQuery(Name = "pageIndex")] int?pageIndex = null,
[FromQuery(Name = "search")] BrandSearch search = null,
[FromQuery(Name = "sort")] BrandSort?sort = null,
[FromQuery(Name = "pageSize")] int pageSize = 10)
{
var spec = new BrandFilterSpec();
if (sort != null)
{
switch (sort)
{
case BrandSort.ProductsAsc:
spec.Query.OrderBy(a => a.Products.Count);
break;
case BrandSort.ProductsDesc:
spec.Query.OrderByDescending(a => a.Products.Count);
break;
default:
break;
}
}
var lambdaCombiner = new LambdaExpressionCombiner <Brand>();
if (search != null)
{
if (!search.Ids.IsNullOrEmpty())
{
lambdaCombiner.Add(new BrandByIdSpec(search.Ids).WhereExpressions.First());
}
if (!search.Names.IsNullOrEmpty())
{
lambdaCombiner.Add(new BrandByNameContainsSpec(search.Names).WhereExpressions.First());
}
}
var lambda = lambdaCombiner.Combine(ExpressionType.AndAlso);
if (lambda != null)
{
spec.Query.Where(lambda);
}
if (pageIndex.HasValue)
{
spec.Query.Paginate(pageIndex.Value * pageSize, pageSize);
var totalCount = 0;
if (lambda is null)
{
totalCount = await _unitOfWork.BrandRepository.CountAsync();
}
else
{
var noPagingSpec = new BrandFilterSpec();
noPagingSpec.Query.Where(lambda);
totalCount = await _unitOfWork.BrandRepository.CountAsync(noPagingSpec);
}
var items = _mapper.Map <IEnumerable <BrandDto> >(await _unitOfWork.BrandRepository.ListAsync(spec));
var paginatedList = new Page <BrandDto>(items, totalCount, pageIndex.Value, pageSize);
return(Ok(paginatedList));
}
return(Ok(_mapper.Map <IEnumerable <BrandDto> >(await _unitOfWork.BrandRepository.ListAsync())));
}
public IActionResult Get([FromBody] BrandSearch search,
[FromServices] IGetBrandsQuery query)
{
return(Ok(executor.ExecuteQuery(query, search)));
}
public async Task <IActionResult> OnPostDataAsync(int page, int rows, BrandSearch where)
{
var data = await _service.GetListAsync(page, rows, where, null);
return(PagerData(data.items, page, rows, data.count));
}
public ActionResult <IEnumerable <BrandResponseDTO> > Get([FromQuery] BrandSearch search)
{
var brands = _getBrands.Execute(search);
return(Ok(brands));
}
