public ActionResult <IEnumerable <OutgoingVehicleDTO> > GetFilteredAds(
[FromHeader, DefaultValue(SortingCriteria.UploadDate)] SortingCriteria sortBy,
[FromHeader, DefaultValue(false)] bool sortAscending,
[FromHeader, DefaultValue(0)] int startIndex,
[FromHeader, DefaultValue(10)] int amount,
[FromHeader] string brand = null,
[FromHeader] string model = null,
[FromHeader] bool?used = null,
[FromHeader] int?priceFrom = null,
[FromHeader] int?priceTo = null,
[FromHeader] string uploaderUsername = null,
[FromHeader] int?yearFrom = null,
[FromHeader] int?yearTo = null,
[FromHeader] FuelType?fuelType = null,
[FromHeader] ChassisType?chassisType = null)
{
VehicleFilters filters = new VehicleFilters
{
Brand = brand,
Model = model,
Used = used,
PriceFrom = priceFrom,
PriceTo = priceTo,
Username = uploaderUsername,
YearFrom = yearFrom,
YearTo = yearTo,
FuelType = fuelType,
ChassisType = chassisType
};
var cars = _services.GetFilteredVehicles(filters, sortBy, sortAscending, startIndex, amount);
return(cars == null?NoContent() : new ActionResult <IEnumerable <OutgoingVehicleDTO> >(cars));
}
// GET: VehicleModel
public async Task <ActionResult> Index(string vehiclemake, string search, int?page, string currentFilter, string sortOrder)
{
var modelmake = await _modelService.GetModels();
ViewBag.Search = search;
string src = "";
if (vehiclemake != null)
{
src = vehiclemake;
}
else
{
src = search;
}
VehicleFilters filter = new VehicleFilters(src, currentFilter);
VehiclePaging paging = new VehiclePaging(page);
var models = await _modelService.GetModelsList(filter, paging);
var makes = modelmake.Select(m => m.VehicleMake.Name).Distinct();
ViewBag.VehicleMake = new SelectList(makes);
List <VehicleModelViewModel> viewModel = _mapper.Map <List <VehicleModelViewModel> >(models);
var pagedList = new StaticPagedList <VehicleModelViewModel>(viewModel, paging.Page ?? 1, paging.PageSize, paging.TotalItems);
FilteringCheck(ViewBag, filter, paging);
return(View(pagedList));
}
// Vehicle Make
public async Task <IEnumerable <VehicleMake> > GetVehicleMakeList(VehicleFilters filters, VehicleSorting sorting, VehiclePaging paging)
{
IQueryable <VehicleMake> vehicles = from vehicle in _entities.VehicleMakes
select vehicle;
//filter/find
if (filters.ShouldApplyFilters())
{
vehicles = vehicles.Where(m => m.Name.Contains(filters.FilterBy) || m.Abrv.Contains(filters.FilterBy));
}
paging.TotalCount = vehicles.Count();
// sort
switch (sorting.SortBy)
{
case "name_desc":
vehicles = vehicles.OrderByDescending(v => v.Name);
break;
case "Abrv":
vehicles = vehicles.OrderBy(v => v.Abrv);
break;
case "abrv_desc":
vehicles = vehicles.OrderByDescending(v => v.Abrv);
break;
default: // sort by name
vehicles = vehicles.OrderBy(v => v.Name);
break;
}
return(await vehicles.Skip(paging.ItemsToSkip).Take(paging.ResultsPerPage).ToListAsync());
}
public async Task <IEnumerable <IVehicleMake> > GetAll(VehicleFilters filters, VehicleSorting sorting, VehiclePaging paging)
{
IQueryable <VehicleMakeEntityModel> vehicles = _genericRepository.GetAll();
if (filters.ShouldApplyFilters())
{
vehicles = vehicles.Where(m => m.Name.Contains(filters.FilterBy) || m.Abrv.Contains(filters.FilterBy));
}
paging.TotalCount = vehicles.Count();
switch (sorting.SortBy)
{
case "name_desc":
vehicles = vehicles.OrderByDescending(v => v.Name);
break;
case "Abrv":
vehicles = vehicles.OrderBy(v => v.Abrv);
break;
case "abrv_desc":
vehicles = vehicles.OrderByDescending(v => v.Abrv);
break;
default:
vehicles = vehicles.OrderBy(v => v.Name);
break;
}
return(await vehicles.Skip(paging.ItemsToSkip).Take(paging.ResultsPerPage).ProjectTo <VehicleMake>(_mapperConfiguration).ToListAsync());
}
public IActionResult GetAll([FromQuery] VehicleFilters filteringParams)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
return(Ok(_filterSvc.GetVehicles(filteringParams, _context)));
}
public IEnumerable <OutgoingVehicleDTO> GetFilteredVehicles(VehicleFilters filters, SortingCriteria sortBy, bool sortAscending, int startIndex, int amount)
{
var v = _repository.GetFilteredVehicles(filters, sortBy, sortAscending, startIndex, amount);
if (v == null)
{
return(null);
}
return(v.Select(x => x.ToOutgoingDTO()));
}
public async Task <IEnumerable <VehicleModel> > GetModelsList(VehicleFilters filter, VehiclePaging page)
{
IQueryable <VehicleModel> model = from m in context.VehicleModels.Include(m => m.VehicleMake) select m;
if (filter.Filters())
{
model = model.Where(v => v.Name.Contains(filter.FilterBy) || v.Abrv.Contains(filter.FilterBy) || v.VehicleMake.Name.Contains(filter.FilterBy));
}
page.TotalItems = model.Count();
return(await model.OrderBy(m => m.Name).Skip(page.Skip).Take(page.PageSize).ToListAsync());
}
public async Task <IEnumerable <VehicleMake> > GetMakesList(VehicleFilters filter, VehiclePaging pageing)
{
IQueryable <VehicleMake> makes = from make in context.VehicleMakes select make;
if (filter.Filters())
{
makes = makes.Where(m => m.Name.Contains(filter.FilterBy) || m.Abrv.Contains(filter.FilterBy));
}
pageing.TotalItems = makes.Count();
return(await makes.OrderBy(m => m.Name).Skip(pageing.Skip).Take(pageing.PageSize).ToListAsync());
}
// GET: VehicleMake
public async Task <ActionResult> Index(string searchString, int?page, string currentFilter, string sortOrder)
{
VehicleFilters filter = new VehicleFilters(searchString, currentFilter);
VehiclePaging paging = new VehiclePaging(page);
var makes = await _vehicleService.GetMakesList(filter, paging);
List <VehicleMakeViewModel> viewModel = _mapper.Map <List <VehicleMakeViewModel> >(makes);
var pagedList = new StaticPagedList <VehicleMakeViewModel>(viewModel, paging.Page ?? 1, paging.PageSize, paging.TotalItems);
SortingCheck(ViewBag, filter, paging);
return(View(pagedList));
}
private void FilteringCheck(dynamic ViewBag, VehicleFilters filter, VehiclePaging page)
{
if (filter.SearchString != null)
{
page.Page = 1;
}
else
{
filter.SearchString = filter.CurrentFilter;
}
ViewBag.CurrentFilter = filter.SearchString;
}
public List <Vehicle> GetVehicles(VehicleFilters filteringParams, VehicleContext context)
{
var query = context.Vehicles.AsQueryable();
if (!filteringParams.IsEmpty)
{
// We were presented with filters, so let's check them and add them to the
// WHERE clause as needed.
// Consider year filters first.
// If the 'YEAR ===' filter is used it takes precedence
// Otherwise consider some combination of the 'YEAR >=' and 'YEAR <=' filters
if (filteringParams.Year.HasValue)
{
query = query.Where(v => v.Year == filteringParams.Year.Value);
}
else if (filteringParams.MinYear.HasValue || filteringParams.MaxYear.HasValue)
{
// we use two if statements instead of if/else to allow for any combination of these two filters
if (filteringParams.MinYear.HasValue)
{
query = query.Where(v => v.Year >= filteringParams.MinYear.Value);
}
if (filteringParams.MaxYear.HasValue)
{
query = query.Where(v => v.Year <= filteringParams.MaxYear.Value);
}
}
// For Make and Model filters, if they ask for an exact match, that takes precedence,
// otherwise we use partial matching if they provided such a filter
if (!string.IsNullOrEmpty(filteringParams.Make))
{
query = query.Where(v => v.Make.ToLowerInvariant() == filteringParams.Make.ToLowerInvariant());
}
else if (!string.IsNullOrEmpty(filteringParams.MakeContains))
{
query = query.Where(v => v.Make.ToLowerInvariant().Contains(filteringParams.MakeContains.ToLowerInvariant()));
}
if (!string.IsNullOrEmpty(filteringParams.Model))
{
query = query.Where(v => v.Model.ToLowerInvariant() == filteringParams.Model.ToLowerInvariant());
}
else if (!string.IsNullOrEmpty(filteringParams.ModelContains))
{
query = query.Where(v => v.Model.ToLowerInvariant().Contains(filteringParams.ModelContains.ToLowerInvariant()));
}
}
return(query.ToList());
}
// GET: VehicleMake
public async Task <ActionResult> Index(string sortBy, string currentFilter, string searchString, int?page)
{
VehicleFilters filters = new VehicleFilters(searchString, currentFilter);
VehicleSorting sorting = new VehicleSorting(sortBy);
VehiclePaging paging = new VehiclePaging(page);
var vehicles = await _vehicleService.GetVehicleMakeListAsync(filters, sorting, paging);
List <VehicleMakeViewModel> vehiclesListDest = iMapper.Map <List <VehicleMakeViewModel> >(vehicles);
var paginatedVehiclesList = new StaticPagedList <VehicleMakeViewModel>(vehiclesListDest, paging.Page ?? 1, paging.ResultsPerPage, paging.TotalCount);
UpdateView(ViewBag, filters, sorting, paging);
return(View(paginatedVehiclesList));
}
public async Task <(List <Car> adList, Response response)> GetFilteredAds(VehicleFilters filters, SortingCriteria sortBy, bool sortAscending, int startIndex, int amount)
{
try
{
var result = await _api.GetFilteredAdsAsync((int)sortBy, sortAscending, startIndex, amount, filters.Brand, filters.Model, filters.Used, filters.PriceFrom,
filters.PriceTo, filters.Username, filters.YearFrom, filters.YearTo, (int?)filters.FuelType, (int?)filters.ChassisType);
return(GetCarList(result), Response.Ok);
}
catch (HttpOperationException)
{
return(null, Response.InvalidResponse);
}
catch (HttpRequestException)
{
NoServerResponse.Invoke();
return(null, Response.NoResponse);
}
}
public async Task <IEnumerable <VehicleModel> > GetVehicleModelList(VehicleFilters filters, VehicleSorting sorting, VehiclePaging paging)
{
IQueryable <VehicleModel> models = from model in _entities.VehicleModels
select model;
if (filters.ShouldApplyFilters())
{
models = models.Where(m => m.Name.Contains(filters.FilterBy) ||
m.Abrv.Contains(filters.FilterBy) ||
m.MakeId.ToString().Contains(filters.FilterBy));
}
paging.TotalCount = models.Count();
// sort
switch (sorting.SortBy)
{
case "name_desc":
models = models.OrderByDescending(v => v.Name);
break;
case "Abrv":
models = models.OrderBy(v => v.Abrv);
break;
case "abrv_desc":
models = models.OrderByDescending(v => v.Abrv);
break;
case "MakeId":
models = models.OrderBy(v => v.MakeId);
break;
case "makeid_desc":
models = models.OrderByDescending(v => v.MakeId);
break;
default: // sort by name
models = models.OrderBy(v => v.Name);
break;
}
return(await models.Skip(paging.ItemsToSkip).Take(paging.ResultsPerPage).ToListAsync());
}
// Index methods
private void UpdateView(dynamic ViewBag, VehicleFilters filters, VehicleSorting sorting, VehiclePaging paging)
{
ViewBag.CurrentSort = sorting.SortBy;
ViewBag.SortByName = sorting.SortByName;
ViewBag.SortByAbrv = sorting.SortByAbrv;
// paging - if searchString is updated, return to page 1
if (filters.SearchString != null)
{
paging.Page = 1;
}
else // else keep the filter
{
filters.SearchString = filters.CurrentFilter;
}
// current filter - keeps filter between pages
ViewBag.CurrentFilter = filters.SearchString;
}
public async Task ShouldReturnEmptyModelList()
{
//Arrange
var vehicleModels = new List <IVehicleModel>().AsEnumerable();
string searchString = "";
string sortBy = "";
int page = 0;
VehicleFilters filters = new VehicleFilters(searchString);
VehicleSorting sorting = new VehicleSorting(sortBy);
VehiclePaging paging = new VehiclePaging(page);
_modelRepoMock.Setup(x => x.GetAll(filters, sorting, paging)).Returns(Task.FromResult(vehicleModels));
//Act
var result = await _sut.GetVehicleModels(filters, sorting, paging);
//Assert
result.Should().BeEmpty();
}
public async Task <IHttpActionResult> GetVehicleModels(string sortBy, string searchString, int?page)
{
VehicleFilters filters = new VehicleFilters(searchString);
VehicleSorting sorting = new VehicleSorting(sortBy);
VehiclePaging paging = new VehiclePaging(page);
IEnumerable <IVehicleModel> vehicleModels = await _vehicleService.GetVehicleModels(filters, sorting, paging);
List <VehicleModelViewModel> vehicleModelsDest = iMapper.Map <List <VehicleModelViewModel> >(vehicleModels);
return(Ok(new
{
models = vehicleModelsDest,
pagingInfo = new
{
resultsPerPage = paging.ResultsPerPage,
totalCount = paging.TotalCount,
pageNumber = paging.Page,
}
}));
}
private void UpdateView(dynamic ViewBag, VehicleFilters filters, VehicleSorting sorting, VehiclePaging paging)
{
// current sort by - keep sorting between pages
ViewBag.CurrentSort = sorting.SortBy;
// sort by
ViewBag.SortByName = String.IsNullOrEmpty(sorting.SortBy) ? "name_desc" : "";
ViewBag.SortByAbrv = sorting.SortBy == "Abrv" ? "abrv_desc" : "Abrv";
ViewBag.SortById = sorting.SortBy == "MakeId" ? "makeid_desc" : "MakeId";
// paging - if searchString is updated, return to page 1
if (filters.SearchString != null)
{
paging.Page = 1;
}
else // else keep the filter
{
filters.SearchString = filters.CurrentFilter;
}
// current filter - keeps filter between pages
ViewBag.CurrentFilter = filters.SearchString;
}
public async Task ShouldReturnModelList()
{
//Arrange
var vehicleModels = new List <IVehicleModel>()
{
new VehicleModel()
{
Id = 1,
Name = "123",
Abrv = "Mercedes",
MakeId = 1
},
new VehicleModel()
{
Id = 2,
Name = "A5",
Abrv = "Audi",
MakeId = 2
},
}.AsEnumerable();
string searchString = "";
string sortBy = "";
int page = 0;
VehicleFilters filters = new VehicleFilters(searchString);
VehicleSorting sorting = new VehicleSorting(sortBy);
VehiclePaging paging = new VehiclePaging(page);
_modelRepoMock.Setup(x => x.GetAll(filters, sorting, paging)).Returns(Task.FromResult(vehicleModels));
//Act
var result = await _sut.GetVehicleModels(filters, sorting, paging);
//Assert
result.Should().BeEquivalentTo(vehicleModels);
}
public async Task <IEnumerable <VehicleModel> > GetModelsList(VehicleFilters filter, VehiclePaging page)
{
return(await _modelRepository.GetModelsList(filter, page));
}
public async Task <ActionResult <IEnumerable <Vehicle> > > GetVehicles([FromQuery] VehicleFilters filters)
{
return(await _context.Vehicles.Include(v => v.User).ToListAsync());
}
public async Task <IEnumerable <VehicleMake> > GetMakesList(VehicleFilters filter, VehiclePaging pages)
{
return(await _vehicleRepository.GetMakesList(filter, pages));
}
public async Task <IEnumerable <IVehicleMake> > GetVehicleMakes(VehicleFilters filters, VehicleSorting sorting, VehiclePaging paging)
{
IEnumerable <IVehicleMake> query = await _repository.GetAll(filters, sorting, paging);
return(query.ToList());
}
public async Task <IEnumerable <VehicleModel> > GetVehicleModelList(VehicleFilters filters, VehicleSorting sorting, VehiclePaging paging)
{
return(await _vehicleRepository.GetVehicleModelList(filters, sorting, paging));
}
