public override List <Model.Vehicle> Get(VehicleSearchRequest search)
{
var query = _context.Vehicles.Include(e => e.VehicleType).Include(e => e.Fuel)
.Include(e => e.Brand).Include(e => e.VehicleModel).AsQueryable();
if (!string.IsNullOrWhiteSpace(search.Name))
{
query = query.Where(w => w.Name.Contains(search.Name));
}
if (search.BrandId > 0)
{
query = query.Where(w => w.BrandId == search.BrandId);
}
if (search.IsActive == false)
{
query = query.Where(w => w.IsActive == false);
}
if (search.IsActive == true)
{
query = query.Where(w => w.IsActive == true);
}
return(_mapper.Map <List <Model.Vehicle> >(query.ToList()));
}
public IEnumerable <Vehicle> GetByCriteria(VehicleSearchRequest request)
{
var vehicles = _repository.GetAll();
if (!string.IsNullOrWhiteSpace(request.Code))
{
vehicles = vehicles.Where(x => x.Code.ToLower().Contains(request.Code.ToLower()));
}
if (!string.IsNullOrWhiteSpace(request.Model))
{
vehicles = vehicles.Where(x => x.Model.ToLower().Contains(request.Model.ToLower()));
}
if (!string.IsNullOrWhiteSpace(request.Brand))
{
vehicles = vehicles.Where(x => x.Brand.ToLower().Contains(request.Brand.ToLower()));
}
if (!string.IsNullOrWhiteSpace(request.RegistrationPlate))
{
vehicles = vehicles.Where(x => x.RegistrationPlate.ToLower().Contains(request.RegistrationPlate.ToLower()));
}
return(vehicles);
}
/// <summary>
/// Get Vehicles
/// </summary>
public HireGroupVehiclesResponse Post(VehicleSearchRequest request)
{
if (request == null || !ModelState.IsValid)
{
throw new HttpException((int)HttpStatusCode.BadRequest, "Invalid Request");
}
return(vehicleService.GetByHireGroup(request).CreateFromFoRa());
}
/// <summary>
/// Get Upgraded Vehicles By HireGroup
/// </summary>
public GetVehicleResponse GetUpgradedVehiclesByHireGroup(VehicleSearchRequest request)
{
var subQuery = from hireGroupDetail in db.HireGroupDetails
join hireGroupUpGrade in db.HireGroupUpGrades on hireGroupDetail.HireGroupId equals hireGroupUpGrade.HireGroupId into hireGroupUpgradeSet
from hgu in hireGroupUpgradeSet.DefaultIfEmpty()
where (hireGroupDetail.HireGroupDetailId == request.HireGroupDetailId || request.HireGroupDetailId == 0)
join hireGroup in db.HireGroups on hireGroupDetail.HireGroupId equals hireGroup.HireGroupId
where (hireGroupDetail.HireGroupDetailId == request.HireGroupDetailId || request.HireGroupDetailId == 0)
select hireGroupDetail;
var query = from hireGroupDetail in db.HireGroupDetails
join hireGroup in subQuery on hireGroupDetail.HireGroupId equals hireGroup.HireGroupId
where (hireGroupDetail.HireGroupDetailId == request.HireGroupDetailId || request.HireGroupDetailId == 0)
join vc in db.VehicleCategories on hireGroupDetail.VehicleCategoryId equals vc.VehicleCategoryId
join vm in db.VehicleMakes on hireGroupDetail.VehicleMakeId equals vm.VehicleMakeId
join vmod in db.VehicleModels on hireGroupDetail.VehicleModelId equals vmod.VehicleModelId
join v in db.Vehicles on new { vc.VehicleCategoryId, vm.VehicleMakeId, vmod.VehicleModelId, hireGroupDetail.ModelYear } equals
new { v.VehicleCategoryId, v.VehicleMakeId, v.VehicleModelId, v.ModelYear }
join vs in db.VehicleStatuses on v.VehicleStatusId equals vs.VehicleStatusId
where vs.AvailabilityCheck
join fleetPool in db.FleetPools on v.FleetPoolId equals fleetPool.FleetPoolId
join owp in db.OperationsWorkPlaces on fleetPool.FleetPoolId equals owp.FleetPoolId
where owp.OperationsWorkPlaceId == request.OperationsWorkPlaceId
join vr in db.VehicleReservations on v.VehicleId equals vr.VehicleId into vehicleGroup
from vg in vehicleGroup.DefaultIfEmpty()
where vg.EndDtTime >= request.StartDtTime && vg.StartDtTime <= request.EndDtTime
orderby hireGroup.HireGroup.HireGroupCode, hireGroup.HireGroup.HireGroupName
group v by new
{
hireGroup.HireGroupId,
hireGroup.HireGroup.HireGroupCode,
hireGroup.HireGroup.HireGroupName,
hireGroupDetail.HireGroupDetailId,
hireGroupDetail.VehicleCategoryId,
hireGroupDetail.VehicleMakeId,
hireGroupDetail.VehicleModelId,
vm.VehicleMakeCode,
vm.VehicleMakeName,
vc.VehicleCategoryCode,
vc.VehicleCategoryName,
vmod.VehicleModelCode,
vmod.VehicleModelName,
v.ModelYear
} into vehicle
select vehicle;
return(new GetVehicleResponse {
Vehicles = query.SelectMany(hgd => hgd).Distinct().ToList()
});
}
/// <summary>
/// Get By Hire Group
/// </summary>
public GetVehicleResponse GetByHireGroup(VehicleSearchRequest request)
{
if (request.AllocationStatusKey == (short)AllocationStatusEnum.Replaced)
{
request.HireGroupDetailId = 0;
}
else if (request.AllocationStatusKey == (short)AllocationStatusEnum.Upgraded)
{
// Get Upgraded Hire Groups
return(vehicleRepository.GetUpgradedVehiclesByHireGroup(request));
}
return(vehicleRepository.GetByHireGroup(request));
}
public override List <Model.Vehicle> GetAll(VehicleSearchRequest request)
{
var query = _context.Set <Database.Vehicle>().AsQueryable();
/* if (!string.IsNullOrEmpty(request.Name))
* {
* query = query.Where(x => x.Name.Contains(request.Name));
* }*/
var list = query.Include(i => i.Model).ToList();
var vehicles = _mapper.Map <List <Model.Vehicle> >(list);
/* foreach (var vehicle in vehicles)
* {
* vehicle.vehicle = vehicle.Name + " " + vehicle.RegistrationNumber;
* }*/
return(vehicles);
}
public async Task Init()
{
search_request1.Username = APIService.Username;
var instructors = await _instructorsService.GetAll <List <Instructor> >(search_request1);
var instructor = instructors[0]; // Returns logged in instructor
InstructorCategorySearchRequest search_request2 = new InstructorCategorySearchRequest();
search_request2.InstructorId = instructor.Id;
var instructors_categories = await _instructor_categoriesService.GetAll <List <Instructor_Category> >(search_request2); // Returns all categories of logged in instructor
InstructorCategoryCandidateSearchRequest search_request3 = new InstructorCategoryCandidateSearchRequest();
search_request3.PolozenTeorijskiTest = true;
search_request3.PolozenTestPrvePomoci = true;
search_request3.PolozenPrakticniTest = false;
search_request3.Prijavljen = false;
search_request3.InstructorId = instructor.Id;
foreach (var instructor_category in instructors_categories)
{
//search_request3.Instructor_CategoryId = instructor_category.Id;
search_request3.CategoryId = instructor_category.CategoryId;
var instructors_categories_candidates = await _instructor_categories_candidateService.GetAll <List <Instructor_Category_Candidate> >(search_request3); // Returns all users of logged in instructors and all categories of that instructor
foreach (var instructor_category_candidate in instructors_categories_candidates)
{
var candidate = await _candidatesService.GetById <Candidate>(instructor_category_candidate.CandidateId);
candidate.category = instructor_category_candidate.Instructor_Category.Category.Name;
candidate.candidate_category = candidate.candidate + " " + "(" + candidate.category + ")";
CandidatesList.Add(candidate);
}
}
VehicleSearchRequest vehicle_search_request = new VehicleSearchRequest();
var vehicles = await _vehiclesService.GetAll <List <Vehicle> >(null);
foreach (var vehicle in vehicles)
{
vehicle.vehicle = vehicle.Model.Name + " " + "(" + vehicle.RegistrationNumber + ")";
VehiclesList.Add(vehicle);
}
}
public async Task Init()
{
if (VehicleFuelTypeList.Count == 0)
{
var vfList = await _vehicleFuelService.Get <List <VehicleFuelTypeModel> >(null);
foreach (var x in vfList)
{
VehicleFuelTypeList.Add(x);
}
}
if (VehicleTransmissionList.Count == 0)
{
var vtList = await _vehicleTransmissionService.Get <List <VehicleTransmissionTypeModel> >(null);
foreach (var x in vtList)
{
VehicleTransmissionList.Add(x);
}
}
if (SelectedFuelType != null || SelectedTransmissionType != null)
{
VehicleSearchRequest request = new VehicleSearchRequest();
if (SelectedFuelType != null)
{
request.VehicleFuelTypeId = SelectedFuelType.VehicleFuelTypeId;
}
if (SelectedTransmissionType != null)
{
request.VehicleTransmissionTypeId = SelectedTransmissionType.VehicleTransmissionTypeId;
}
await LoadVehicles(request);
await LoadRecommendedVehicles(request);
}
if (SelectedFuelType == null && SelectedTransmissionType == null)
{
await LoadVehicles();
await LoadRecommendedVehicles();
}
}
private async Task LoadVehicles(int?manufacturerId = 0, int?fuelId = 0, int?transmissionId = 0)
{
var manufacturerList = await _vehicleManufacturerService.Get <List <VehicleManufacturerModel> >(null);
var fuelList = await _vehicleFuelTypeService.Get <List <VehicleFuelTypeModel> >(null);
var transmissionList = await _vehicleTransmissionService.Get <List <VehicleTransmissionTypeModel> >(null);
var modelsList = await _vehicleModelService.Get <List <VehicleModelModel> >(null);
if (manufacturerId != 0 || fuelId != 0 || transmissionId != 0)
{
var request = new VehicleSearchRequest();
if (manufacturerId != 0)
{
request.VehicleManufacturerId = manufacturerId;
}
if (fuelId != 0)
{
request.VehicleFuelTypeId = fuelId;
}
if (transmissionId != 0)
{
request.VehicleTransmissionTypeId = transmissionId;
}
var vehicleList = await _vehicleService.Get <List <OpenRoads.Model.VehicleModel> >(request);
var result = GenerateResult(vehicleList, manufacturerList, fuelList, transmissionList, modelsList);
dgvVehicle.AutoGenerateColumns = false;
dgvVehicle.DataSource = result;
}
else
{
var vehicleList = await _vehicleService.Get <List <OpenRoads.Model.VehicleModel> >(null);
var result = GenerateResult(vehicleList, manufacturerList, fuelList, transmissionList, modelsList);
dgvVehicle.AutoGenerateColumns = false;
dgvVehicle.DataSource = result;
}
}
private async void btnShowVehicles_Click(object sender, EventArgs e)
{
var search = new VehicleSearchRequest()
{
ManufacturerName = txtSearchVehicle.Text,
ModelName = txtModelName.Text,
Transmission = txtTransmission.Text,
RegistrationNumber = txtRegistrationNumber.Text,
FuelName = txtFuelName.Text,
BranchName = txtBranchName.Text
};
var result = await _service.Get <List <Data.Model.Vehicle> >(search);
List <frmAllVehiclesVM> finalList = new List <frmAllVehiclesVM>();
foreach (var item in result)
{
frmAllVehiclesVM form = new frmAllVehiclesVM
{
VehicleId = item.VehicleId,
ManufacturerName = item.VehicleModel.Manufacturer.ManufacturerName,
ModelName = item.VehicleModel.ModelName,
RegistrationNumber = item.RegistrationNumber,
Image = item.Image,
Mileage = item.Mileage,
Transmission = item.Transmission,
NumberOfSeats = item.NumberOfSeats,
FuelName = item.FuelType.FuelName,
BranchName = item.Branch.BranchName
};
finalList.Add(form);
}
dgvVehicles.AutoGenerateColumns = false;
dgvVehicles.DataSource = finalList;
if (finalList.Count == 0)
{
MessageBox.Show("There are no results for this search", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
/// <summary>
/// Get Vehicle List Based On Search Criteria
/// </summary>
public GetVehicleResponse GetVehicles(VehicleSearchRequest request)
{
int fromRow = (request.PageNo - 1) * request.PageSize;
int toRow = request.PageSize;
Expression <Func <Vehicle, bool> > query =
s => (string.IsNullOrEmpty(request.SearchString) || s.VehicleName.Contains(request.SearchString) || s.PlateNumber.Contains(request.SearchString)) &&
(string.IsNullOrEmpty(request.HireGroupString) || s.VehicleMake.VehicleMakeCode.Contains(request.HireGroupString) || s.VehicleMake.VehicleMakeName.Contains(request.HireGroupString) ||
s.VehicleModel.VehicleModelCode.Contains(request.HireGroupString) || s.VehicleModel.VehicleModelName.Contains(request.HireGroupString) ||
s.VehicleCategory.VehicleCategoryCode.Contains(request.HireGroupString) || s.VehicleCategory.VehicleCategoryName.Contains(request.HireGroupString)) &&
(request.OperationId == null || s.OperationsWorkPlace.Operation.OperationId == request.OperationId) &&
(request.FleetPoolId == null ||
s.FleetPoolId == request.FleetPoolId);
IEnumerable <Vehicle> vehicles = request.IsAsc ? DbSet.Where(query)
.OrderBy(vehicleOrderByClause[request.VehicleOrderBy]).Skip(fromRow).Take(toRow).ToList()
: DbSet.Where(query)
.OrderByDescending(vehicleOrderByClause[request.VehicleOrderBy]).Skip(fromRow).Take(toRow).ToList();
return(new GetVehicleResponse {
Vehicles = vehicles, TotalCount = DbSet.Count(query)
});
}
//Load search vehicles
public async Task Load()
{
var request = new VehicleSearchRequest
{
ManufacturerName = ManufacturerName,
BranchName = BranchName
};
var list = await _vehicleService.Get <IEnumerable <Data.Model.Vehicle> >(request);
VehicleList.Clear();
foreach (var item in list)
{
VehicleList.Add(item);
}
if (VehicleList.Count == 0)
{
await Application.Current.MainPage.DisplayAlert("Warning", "We do not offer this brand of vehicle", "Try again");
}
}
private async Task LoadRecommendedVehicles(VehicleSearchRequest request = null)
{
var vehicleManufacturers = await _vehicleManufacturerService.Get <List <VehicleManufacturerModel> >(null);
var vehicleModels = await _vehicleModelService.Get <List <VehicleModelModel> >(null);
var reservationsList = await _reservationService.Get <List <ReservationModel> >(null);
var recommenderVehicles = await _recommenderService.GetById <List <VehicleModel> >(APIService.LoggedUserId);
DateTime dateToCheck = new DateTime(0001, 1, 1);
bool vehicleRented = false;
RecommendedVehiclesList.Clear();
if (recommenderVehicles.Count <= 3)
{
foreach (var x in recommenderVehicles)
{
vehicleRented = false;
foreach (var reservation in reservationsList)
{
if (reservation.VehicleId == x.VehicleId)
{
if (SelectedDateTo != dateToCheck)
{
if (SelectedDateFrom >= reservation.DateFrom && SelectedDateFrom <= reservation.DateTo)
{
vehicleRented = true;
}
if ((SelectedDateFrom < reservation.DateFrom && SelectedDateFrom < reservation.DateTo) &&
(SelectedDateTo >= reservation.DateFrom && SelectedDateTo <= reservation.DateTo))
{
vehicleRented = true;
}
if (reservation.DateFrom >= SelectedDateFrom && reservation.DateTo <= SelectedDateTo)
{
if (reservation.DateTo > DateTime.Now)
{
vehicleRented = true;
}
}
}
}
}
if (!vehicleRented)
{
VehicleToDisplay newVehicle = new VehicleToDisplay();
newVehicle.VehicleId = x.VehicleId;
newVehicle.Available = x.Available;
newVehicle.Picture = x.Picture;
newVehicle.DailyPrice = x.PriceByDay + " KM";
newVehicle.PowerHP = x.PowerInHp + " hp";
newVehicle.ManufacturedYear = x.ManufacturedYear;
foreach (var model in vehicleModels)
{
if (x.VehicleModelId == model.VehicleModelId)
{
foreach (var manufacturer in vehicleManufacturers)
{
if (model.VehicleManufacturerId == manufacturer.VehicleManufacturerId)
{
newVehicle.VehicleName = manufacturer.Name + " " + model.Name;
break;
}
}
break;
}
}
RecommendedVehiclesList.Add(newVehicle);
}
}
}
}
public IEnumerable <VehicleSearchResponseVehicleSearchResult> FindVehicles(VehicleSearchRequest query)
{
return(SubmitRequest <VehicleSearchResponse>(query).Items);
}
public IActionResult GetByCriteria([FromQuery]VehicleSearchRequest request)
{
var vehicles = _vehicleService.GetByCriteria(request);
return Ok(vehicles);
}
/// <summary>
/// Get Vehicles List Based on search Criteria
/// </summary>
/// <returns></returns>
public GetVehicleResponse LoadVehicles(VehicleSearchRequest request)
{
return(vehicleRepository.GetVehicles(request));
}
private async void btnSacuvaj_Click(object sender, EventArgs e)
{
if (this.ValidateChildren())
{
request.RegistrationNumber = txtRegistrationNumber.Text;
request.VehicleNumber = int.Parse(txtVehicleNumber.Text);
request.DailyPrice = double.Parse(txtDailyPrice.Text);
request.Description = rtxDescription.Text;
request.ManufacturerDate = dtDte.Value;
request.Mileage = txtMileage.Text;
request.Transmission = txtTransmission.Text;
request.NumberOfSeats = int.Parse(txtNumberOfSeats.Text);
request.Status = chkStatus.Checked;
// ove foreign moraju se posebno parsat
var idBranch = cmbBranch.SelectedValue;
if (int.TryParse(idBranch.ToString(), out int branchID))
{
request.BranchId = branchID;
}
var idFuel = cmbFuelType.SelectedValue;
if (int.TryParse(idFuel.ToString(), out int fuelid))
{
request.FuelTypeId = fuelid;
}
var idVehicleType = cmbVehicleType.SelectedValue;
if (int.TryParse(idVehicleType.ToString(), out int vehicletypeID))
{
request.VehicleTypeId = vehicletypeID;
}
var idVehiclemodel = cmbVehicleModel.SelectedValue;
if (int.TryParse(idVehiclemodel.ToString(), out int vehiclemodelID))
{
request.VehicleModelId = vehiclemodelID;
}
var search = new VehicleSearchRequest
{
RegistrationNumber = txtRegistrationNumber.Text
};
var list = await _serviceVehicle.Get <List <Data.Model.Vehicle> >(search);
if (list.Count >= 1)
{
MessageBox.Show("A car with this registration number already exists, please try again", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
else
{
await _serviceVehicle.Insert <Data.Model.Vehicle>(request);
MessageBox.Show("Operation successfully completed!", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
this.Close();
}
}
}
