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)); }