public async Task <Envelope <Vehicle> > List(VehicleFilter filter)
{
var envelope = new Envelope <Vehicle>();
var query = _context.Vehicles
.Include(v => v.Model)
.ThenInclude(m => m.Make)
.Include(v => v.Features)
.ThenInclude(vf => vf.Feautre)
.AsQueryable(); //After Include it returns IIncludableQueryable so we have to change it.
query = query.ApplyVehicleFiltering(filter);
var path = new Dictionary <string, Expression <Func <Vehicle, object> > >()
{
["make"] = v => v.Model.Make.Name,
["model"] = v => v.Model.Name,
["contactName"] = v => v.ContactName,
["userId"] = v => v.UserId,
};
query = query.ApplyOrdering(filter, path);
envelope.TotalItems = await query.CountAsync();
query = query.ApplyPaging(filter);
envelope.Items = await query.ToListAsync();
return(envelope);
}
public async Task <IActionResult> ListAsync([ModelBinder(typeof(FilterModelBinder))] VehicleFilter filter,
CancellationToken cancellationToken)
{
var result = await _vehicleService.ListAsync(filter, cancellationToken);
return(result.GetActionResult(ActionResultFactory));
}
public async Task <IEnumerable <OXODoc> > ListAvailableOxoDocuments(VehicleFilter filter)
{
return(await Task.FromResult(_documentDataStore
.OXODocGetManyByUser(this.CDSID)
.Where(d => IsDocumentForVehicle(d, VehicleFilter.ToVehicle(filter)))
.Distinct(new OXODocComparer())));
}
public IActionResult Index(decimal?minPrice = null,
decimal?maxPrice = 50000, int size = 10, int page = 1)
{
try
{
var filter = new VehicleFilter {
MinPrice = minPrice, Size = size, MaxPrice = maxPrice, Skip = ((page - 1) * size),
IncludePhotos = true
};
var vehicles = _vehicleService.GetAll(filter).Select(x => _mapper.Map <VehicleViewModel>(x));
var viewModel = new InventoryViewModel
{
Vehicles = vehicles,
Pagination = new Pagination(vehicles.Count(), size, page)
};
return(View(viewModel));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(RedirectToAction("Index", "Home"));
}
}
private IQueryable <Vehicle> FindVehicles(VehicleFilter filter)
{
IQueryable <Vehicle> query = null;
if (filter.MakeId.HasValue)
{
query = vehicleRepository.FindBy(v => v.Model.MakeId == filter.MakeId);
}
else if (filter.ModelId.HasValue)
{
if (query == null)
{
query = vehicleRepository.FindBy(v => v.ModelId == filter.ModelId);
}
else
{
query = query.Where(v => v.ModelId == filter.ModelId);
}
}
else
{
query = vehicleRepository.GetAll();
}
return(query);
}
/// <summary>
/// Gets vehicles.
/// </summary>
/// <param name="id">Id.</param>
/// <param name="makerId">Maker id.</param>
/// <param name="findVehicle">Find vehicle.</param>
/// <param name="sortField">Sort field.</param>
/// <param name="sortOrder">Sort order.</param>
/// <param name="pageNumber">Page number.</param>
/// <param name="pageSize">Page size.</param>
/// <param name="sorting">Sorting.</param>
/// <returns>Vehicles.</returns>
public async Task <ActionResult> GetVehicles(Guid id, Guid?makerId, string findVehicle, string sortField, string sortOrder, int pageNumber = 1, int pageSize = 12, string sorting = "VehicleMaker.Name")
{
try
{
PagingParameters paging = new PagingParameters(pageNumber, pageSize);
VehicleFilter filtering = new VehicleFilter(id, findVehicle, makerId);
ViewBag.SortMaker = sorting == "VehicleMaker.Name" ? "VehicleMaker.Name desc" : "VehicleMaker.Name";
if (sorting.Contains("desc"))
{
string[] sorts = sorting.Split();
sortField = sorts[0];
sortOrder = sorts[1];
}
else
{
sortField = sorting;
sortOrder = "";
}
SortingParameters sortingFilter = new SortingParameters(sortField, sortOrder);
ViewBag.Makers = new SelectList(await makerService.GetMakersAsync(), "Id", "Name");
ViewBag.CurrentSort = sorting;
ViewBag.CurrentSearch = findVehicle;
ViewBag.CurrentMaker = makerId;
return(View(await vehicleService.GetVehiclesAsync(paging, filtering, sortingFilter)));
}
catch
{
return(new HttpNotFoundResult("There are no vehicles"));
}
}
public async Task <IEnumerable <Vehicle> > Get(Guid?customerId, VehicleStatus?status)
{
_logger.LogInformation($"Request vehicles CustomerId={customerId?.ToString() ?? "All"}, Status={status?.ToString() ?? "All"}");
var filter = new VehicleFilter
{
CustomerId = customerId
};
var storageData = await _repository.List(filter);
_logger.LogTrace($"Found {storageData.Count()} vehicles");
await _bus.SendSubscribeRequest(new VehicleTrackSubscribeRequest(storageData.Select(x => x.Id)));
_logger.LogInformation($"Subscribed on {storageData.Count()} vehicles");
var statuses = await _statusCache.ExtractStatuses(storageData);
_logger.LogTrace($"Statuses extracted");
var customers = await _customerService.ExtractCustomers(storageData);
_logger.LogTrace($"Customers extracted");
var result = storageData.Select(v => v.ToVehicle(statuses[v.Id], customers[v.CustomerId]));
if (status != null)
{
result = result.Where(v => v.Status == status);
}
return(result);
}
public async void Should_Return_Filtered_Vehicles()
{
// Arrange
var vehicles = DataProvider.GetVehicles();
var vehiclesMock = vehicles.AsQueryable().BuildMock();
var filter = new VehicleFilter
{
Manufacturer = "Ford"
};
var vehicleRepositoryMock = new Mock <IGenericRepository <Vehicle, int> >();
vehicleRepositoryMock.Setup(m => m.Get()).Returns(vehiclesMock.Object);
var vehicleController = new VehicleController(vehicleRepositoryMock.Object,
Mock.Of <IGenericRepository <VehicleModel, int> >(),
Mock.Of <IGenericRepository <Booking, int> >(),
Mock.Of <IGenericRepository <Insurance, int> >(),
MapperProvider.GetMapper());
// Act
var request = await vehicleController.Get(filter);
var result = request as OkObjectResult;
// Assert
Assert.NotNull(result);
Assert.True(result.StatusCode == 200);
var dtos = result.Value as List <VehicleListItemDto>;
Assert.NotNull(dtos);
Assert.True(dtos.Count == 2);
}
public List <VehicleDTO> Get(VehicleFilter filter)
{
var items = (from v in Context.Vehicle.Include(x => x.ColorType)
.Include(x => x.FuelType)
.Include(x => x.VehicleClassType)
.Include(x => x.TireType)
.Include(x => x.TransmissionType)
.Include(x => x.VehicleModel.VehicleBrand)
where 1 == 1 &&
(filter.VehicleModelId > 0 ? v.VehicleModelId == filter.VehicleModelId : true) &&
(filter.TransmissionTypeId > 0 ? v.TransmissionTypeId == filter.TransmissionTypeId : true) &&
(filter.TireTypeId > 0 ? v.TireTypeId == filter.TireTypeId : true) &&
(filter.FuelTypeId > 0 ? v.FuelTypeId == filter.FuelTypeId : true) &&
(filter.ColorTypeId > 0 ? v.ColorTypeId == filter.ColorTypeId : true) &&
(filter.VehicleClassTypeId > 0 ? v.VehicleClassTypeId == filter.VehicleClassTypeId : true)
&&
(
(filter.ProductionYearRange.Start.HasValue ? v.ProductionYear >= filter.ProductionYearRange.Start.Value : true)
&&
(filter.ProductionYearRange.End.HasValue ? v.ProductionYear <= filter.ProductionYearRange.End.Value : true)
)
&&
(
(filter.EngineDisplacementRange.Start.HasValue ? v.EngineDisplacement >= filter.EngineDisplacementRange.Start.Value : true)
&&
(filter.EngineDisplacementRange.End.HasValue ? v.EngineDisplacement <= filter.EngineDisplacementRange.End.Value : true)
)
&&
(
(filter.HorsepowerRange.Start.HasValue ? v.Horsepower >= filter.HorsepowerRange.Start.Value : true)
&&
(filter.HorsepowerRange.End.HasValue ? v.Horsepower <= filter.HorsepowerRange.End.Value : true)
)
select new VehicleDTO
{
ColorTypeId = v.ColorTypeId,
ColorTypeName = v.ColorType.Name,
Description = v.Description,
EngineDisplacement = v.EngineDisplacement,
FuelTypeId = v.FuelTypeId,
FuelTypeName = v.FuelType.Name,
Horsepower = v.Horsepower,
Id = v.Id,
ProductionYear = v.ProductionYear,
TireTypeId = v.TireTypeId,
TireTypeName = v.TireType.Name,
TransmissionTypeId = v.TransmissionTypeId,
TransmissionTypeName = v.TransmissionType.Name,
VehicleBrandId = v.VehicleModel.VehicleBrandId,
VehicleBrandName = v.VehicleModel.VehicleBrand.Name,
VehicleClassTypeId = v.VehicleClassTypeId,
VehicleClassTypeName = v.VehicleClassType.Name,
VehicleModelId = v.VehicleModelId,
VehicleModelName = v.VehicleModel.Name
}).ToList();
return(items);
}
private static async Task <IVehicle> InitialiseVehicle(IVehicle vehicle, IDataContext context)
{
var returnValue = await context.Vehicle.GetVehicle(VehicleFilter.FromVehicle(vehicle));
returnValue.TrimMappings = vehicle.TrimMappings;
return(returnValue);
}
public FilteredList <Vehicle> GetVehiclesOfACustomer(VehicleFilter filter, int id)
{
if (id == 0)
{
throw new InvalidDataException("Cannot get vehicle by ID without user ID!");
}
return(_repo.ReadAll(filter));
}
[HttpPost]//post işleminde hangi verileri almam lazım ne göndermem lazım bu sorunun cevabı modelini belirler.
public IActionResult Index(VehicleFilter filter)
{
var items = VehicleService.GetListItems(filter);
ViewBag.Vehicle = items;
SetParametersToViewBag();
return(View(filter));
}
public IActionResult Index(VehicleFilter filter)
{
List <VehicleListItemDTO> items = VehicleService.GetListItems(filter);
ViewBag.Vehicles = items;
DropdownViewBag();
return(View(filter));
}
public IActionResult Status(VehicleFilter vehicleFilter)
{
ViewBag.Codename = vehicleFilter.Codename;
ViewBag.OperationCity = vehicleFilter.OperationCity;
var vehicles = _vehicleRest.FindPaginated(vehicleFilter);
return(View(vehicles));
}
public IEnumerable <Vehicle> GetAll(int?amount = null)
{
var filter = new VehicleFilter {
Size = amount
};
return(GetAll(filter).ToList());
}
public IActionResult Index(VehicleFilter vehiclefilter)
{
ViewBag.VehicleName = vehiclefilter.VehicleName;
ViewBag.Plate = vehiclefilter.VehiclePlate;
var vehicles = _vehicleRest.FindPaginated(vehiclefilter);
return(View(vehicles));
}
public IActionResult Index()
{
VehicleFilter filter = new VehicleFilter();
List <VehicleListItemDTO> list = VehicleService.GetListItems(filter);
ViewBag.Vehicles = list;
DropdownViewBag();
return(View(filter));
}
public async Task <BaseModel <Vehicle> > GetVehicles(VehicleFilter filter)
{
var result = new BaseModel <Vehicle>();
var query = context.Vehicles
.Include(v => v.Model)
.ThenInclude(m => m.Make)
.Include(i => i.Features)
.ThenInclude(vf => vf.Feature).AsQueryable();
if (filter.MakeId.HasValue)
{
query = query.Where(a => a.Model.MakeId == filter.MakeId);
}
var columnsMap = new Dictionary <string, Expression <Func <Vehicle, object> > >()
{
["make"] = v => v.Model.Make.Name,
["model"] = v => v.Model.Name,
["contractName"] = v => v.ContactName,
["id"] = v => v.Id
};
if (!string.IsNullOrEmpty(filter.SortBy))
{
if (filter.IsSortAscending)
{
query = query.OrderBy(columnsMap[filter.SortBy]);
}
else
{
query = query.OrderByDescending(columnsMap[filter.SortBy]);
}
}
//if (filter.SortBy == "make")
// query = (filter.IsSortAscending) ? query.OrderBy(o => o.Model.Make.Name) : query.OrderByDescending(o => o.Model.Make.Name);
//if (filter.SortBy == "model")
// query = (filter.IsSortAscending) ? query.OrderBy(o => o.Model.Name) : query.OrderByDescending(o => o.Model.Name);
//if (filter.SortBy == "contactName")
// query = (filter.IsSortAscending) ? query.OrderBy(o => o.ContactName) : query.OrderByDescending(o => o.ContactName);
result.TotalItems = await query.CountAsync();
if (filter.Page <= 0)
{
filter.Page = 1;
}
if (filter.PageSize <= 0)
{
filter.PageSize = 10;
}
query = query.Skip((filter.Page - 1) * filter.PageSize).Take(filter.PageSize);
result.Items = await query.ToListAsync();
return(result);
}
public async Task <IVehicle> GetVehicle(ProgrammeFilter filter)
{
var vehicleFilter = new VehicleFilter()
{
ProgrammeId = filter.ProgrammeId,
Code = filter.Code
};
return(await GetVehicle(vehicleFilter));
}
// GET: VehicleController
public ActionResult Index()
{
VehicleFilter filter = new VehicleFilter();
List <VehicleDTO> list = VehicleService.Get(filter);
VehicleViewModel model = new VehicleViewModel();
model.Filter = filter;
model.Vehicles = list;
DropdownViewBag();
return(View(model));
}
public IEnumerable <IVehicle> ListAvailableVehicles(VehicleFilter filter)
{
var programmes = ListProgrammes(filter);
if (programmes == null || !programmes.Any())
{
return(Enumerable.Empty <IVehicle>());
}
return(programmes.Select(p => HydrateVehicleFromProgramme(p, filter.VehicleIndex)));
}
public async Task <IActionResult> Get([FromQuery] VehicleFilter filter)
{
var query = filter.Filter(vehicleRepository.Get());
var vehicles = await query
.Include(v => v.VehicleModel)
.Include(v => v.Location)
.ToListAsync();
return(Ok(mapper.Map <IEnumerable <VehicleListItemDto> >(vehicles)));
}
// GET: VehicleController
public ActionResult Index()
{
VehicleFilter filter = new VehicleFilter();
var items = VehicleService.Get(filter);
VehicleViewModel model = new VehicleViewModel();
model.Filter = filter;
model.Vehicles = items;
SetParametersToViewBag();
return(View(model));
}
public async Task <IActionResult> GetVehiclesAsync([FromQuery] VehicleFilter filter)
{
var vehicles = await vehiclesService.GetVehiclesAsync(filter);
if (vehicles.TotalItems > 0)
{
return(Ok(vehicles));
}
return(NoContent());
}
private VehicleViewModel GetFullAndPartialVehicleViewModel(VehicleFilter filter)
{
var vehicleViewModel = new VehicleViewModel()
{
VehicleIndex = filter.VehicleIndex,
Filter = filter,
AvailableVehicles = ListAvailableVehicles(filter),
PageSize = this.PageSize,
PageIndex = this.PageIndex
};
return(vehicleViewModel);
}
public static async Task <LookupViewModel> GetModelForVehicle(IVehicle forVehicle, IDataContext context)
{
var model = GetModel(context);
model.LookupVehicle = await context.Vehicle.GetVehicle(VehicleFilter.FromVehicle(forVehicle));
model.Makes = model.ListMakes();
model.Programmes = model.ListProgrammes();
model.ModelYears = model.ListModelYears();
model.Gateways = model.ListGateways();
model.TrimLevels = model.ListTrimLevels();
return(model);
}
public List <VehicleListItemDTO> GetListItems(VehicleFilter filter)
{
var items = (from v in Context.Vehicle.Include(x => x.FuelType)
.Include(x => x.TransmissionType)
.Include(x => x.VehicleModel.VehicleBrand)
.Include(x => x.VehicleImage)
.Include(x => x.VehicleRentalPrice)
where 1 == 1 &&
v.VehicleRentalPrice.Count(p => p.StartDate <= DateTime.Today && p.EndDate >= DateTime.Today) > 0 &&
(filter.VehicleModelId > 0 ? v.VehicleModelId == filter.VehicleModelId : true) &&
(filter.TransmissionTypeId > 0 ? v.TransmissionTypeId == filter.TransmissionTypeId : true) &&
(filter.TireTypeId > 0 ? v.TireTypeId == filter.TireTypeId : true) &&
(filter.FuelTypeId > 0 ? v.FuelTypeId == filter.FuelTypeId : true) &&
(filter.ColorTypeId > 0 ? v.ColorTypeId == filter.ColorTypeId : true) &&
(filter.VehicleClassTypeId > 0 ? v.VehicleClassTypeId == filter.VehicleClassTypeId : true)
&&
(
(filter.ProductionYearRange.Start.HasValue ? v.ProductionYear >= filter.ProductionYearRange.Start.Value : true)
&&
(filter.ProductionYearRange.End.HasValue ? v.ProductionYear <= filter.ProductionYearRange.End.Value : true)
)
&&
(
(filter.EngineDisplacementRange.Start.HasValue ? v.EngineDisplacement >= filter.EngineDisplacementRange.Start.Value : true)
&&
(filter.EngineDisplacementRange.End.HasValue ? v.EngineDisplacement <= filter.EngineDisplacementRange.End.Value : true)
)
&&
(
(filter.HorsepowerRange.Start.HasValue ? v.Horsepower >= filter.HorsepowerRange.Start.Value : true)
&&
(filter.HorsepowerRange.End.HasValue ? v.Horsepower <= filter.HorsepowerRange.End.Value : true)
)
select new VehicleListItemDTO
{
FuelTypeName = v.FuelType.Name,
Id = v.Id,
TransmissionTypeName = v.TransmissionType.Name,
VehicleBrandName = v.VehicleModel.VehicleBrand.Name,
VehicleModelName = v.VehicleModel.Name,
ImageUrl = v.VehicleImage.Count() > 0 ? v.VehicleImage.FirstOrDefault().ImageUrl: "",
Price = v.VehicleRentalPrice.Where(p => p.StartDate <= DateTime.Today && p.EndDate >= DateTime.Today)
.OrderBy(p => p.Price).FirstOrDefault().Price
}).ToList();
return(items);
}
public IActionResult Index()
{
var filter = new VehicleFilter {
Size = 3, IncludePhotos = true
};
var viewModel = new HomeViewModel
{
VehiclesForSale = _vehicleService.Find(x => x.AvailableStatus == VehicleAvailabilityStatus.Available, filter)
.Select(x => _mapper.Map <VehicleViewModel>(x))
};
return(View(viewModel));
}
public VehicleRequest(
ControllerContext controller,
VehicleFilter model,
IMessageRequest <VehicleFilterModel, IEnumerable <DomainModels.Business.VehicleDomain.Vehicle> > request,
MiddlewareConfiguration middlewareConfiguration,
Guid correlationId,
IOperationalUnit operationalUnit)
{
_controller = controller;
_model = model;
_correlationId = correlationId;
_operationalUnit = operationalUnit;
_request = request;
_middlewareConfiguration = middlewareConfiguration;
}
private IEnumerable <IVehicle> ListAvailableVehicles(VehicleFilter filter)
{
var cacheKey = string.Format("VehicleFilter_{0}", filter.GetHashCode());
IEnumerable <IVehicle> vehicles = (IEnumerable <IVehicle>)HttpContext.Cache.Get(cacheKey);
if (vehicles != null)
{
return(vehicles);
}
vehicles = DataContext.Vehicle.ListAvailableVehicles(filter);
HttpContext.Cache.Add(cacheKey, vehicles, null, DateTime.Now.AddMinutes(60), Cache.NoSlidingExpiration, CacheItemPriority.Default, null);
return(vehicles);
}
public void GetVehiclesPagedList_Valid()
{
var vehicleService = ServiceMiniMart.CreateVehicleService();
var vehicleFilter = new VehicleFilter();
// vehicleFilter.VehicleId = 1;
var v = vehicleService.GetVehicles(vehicleFilter, 0, 10);
Assert.Greater(v.Items.Count, 0);
}
