public void editvehicle(Client player, string choice)
{
AccountController account = player.getData("ACCOUNT");
if (account == null)
{
return;
}
if (!AdminController.AdminRankCheck("createvehicle", account))
{
return;
}
Vehicles.VehicleController _VehicleController = EntityManager.GetVehicle(player.vehicle);
Data.Vehicle VM = _VehicleController.VehicleData;
if (VM != null)
{
if (choice == "position")
{
Vector3 newPos = player.vehicle.position + new Vector3(0.0f, 0.0f, 0.5f);
VM.PosX = newPos.X;
VM.PosY = newPos.Y;
VM.PosZ = newPos.Z;
player.sendChatMessage("You ~g~successfully ~w~set the vehicle's position.");
ContextFactory.Instance.SaveChanges();
}
}
else
{
player.sendChatMessage("~r~ERROR: ~w~You are not in a vehicle.");
}
}
public void CreateVehicle(Client player, int characterId, int groupId, VehicleHash hash, int color1, int color2)
{
if (!AdminController.AdminRankCheck(player, "createvehicle"))
{
return;
}
var vehicleData = new Data.Vehicle
{
CharacterId = characterId == 0 ? (int?)null : characterId,
GroupId = groupId == 0 ? (int?)null : groupId,
Model = hash.GetHashCode(),
PosX = player.position.X,
PosY = player.position.Y,
PosZ = player.position.Z,
Rot = player.rotation.Z,
Color1 = color1,
Color2 = color2,
Fuel = 50,
FuelTank = 50,
RentTime = 999,
Respawnable = true
};
var vehicleController = new VehicleController(vehicleData, API.createVehicle(hash, player.position, player.rotation, color1, color2, 0));
ContextFactory.Instance.Vehicle.Add(vehicleData);
ContextFactory.Instance.SaveChanges();
}
public VehicleController(Data.Vehicle VehicleData, Vehicle vehicle)
{
this.VehicleData = VehicleData;
Vehicle = vehicle;
API.setVehicleEngineStatus(vehicle, false); // Engine is always off.
EntityManager.Add(this);
}
public static void UpdateEntity(this Data.Vehicle entity, RegiX.Client.ResponseModels.Vehicle model)
{
if (model == null || entity == null)
{
return;
}
entity.RegistrationNumber = model.VehicleRegistrationNumber;
entity.FirstRegistrationDate = model.FirstRegistrationDateSpecified ? DateTime.SpecifyKind(model.FirstRegistrationDate, DateTimeKind.Utc) : default(DateTime?);
entity.Vin = model.VINNumber;
entity.EngineNumber = model.EngineNumber;
entity.VehicleType = model.MotorVehicleType;
entity.Model = model.MotorVehicleModel;
entity.TradeDescription = model.TradeDescription;
entity.Color = model.Color;
entity.Category = model.Category;
entity.VehicleOwner = new List <VehicleOwner>();
entity.VehicleOwner.Add(new VehicleOwner
{
BulgarianCitizenPin = model.OwnerPersonData?.EGN,
BulgarianCitizenFirstName = model.OwnerPersonData?.FirstName,
BulgarianCitizenMiddleName = model.OwnerPersonData?.Surname,
BulgarianCitizenLastName = model.OwnerPersonData?.FamilyName,
ForeignCitizenPin = model.OwnerForeignerPersonData?.EGN,
ForeignCitizenPn = model.OwnerForeignerPersonData?.LNCh,
ForeignCitizenNamesCyrillic = model.OwnerForeignerPersonData?.Names,
ForeignCitizenNamesLatin = model.OwnerForeignerPersonData?.NamesLatin,
CompanyId = model.OwnerEntityData?.Identifier,
CompanyName = model.OwnerEntityData?.Name,
CompanyNameLatin = model.OwnerEntityData?.NameLatin,
});
return;
}
private void CheckIfCategoryIsChanged(Vehicle vehicle, Data.Vehicle vehicleDb)
{
var categoryType = ValidateVehicleCategory(vehicle);
if (vehicleDb.Category.Type != categoryType)
{
throw new ChangedVehicleCategoryException(vehicleDb.Category.Type);
}
}
public static void LoadVehicle(AccountController account, int id)
{
Data.Vehicle VM = ContextFactory.Instance.Vehicle.Where(x => x.Id == id).FirstOrDefault();
if (VM != null)
{
VehicleController _vehicle = new VehicleController(VM, API.shared.createVehicle((VehicleHash)VM.Model, new Vector3(VM.PosX, VM.PosY, VM.PosZ), new Vector3(0.0f, 0.0f, VM.Rot), VM.Color1, VM.Color2));
API.shared.sendNotificationToPlayer(account.Client, "You spawned your " + API.shared.getVehicleDisplayName((VehicleHash)VM.Model));
}
}
public async Task <HoursInParking> CalculateHoursSpentInParking(Data.Vehicle vehicle)
{
var parkingLot = await Get();
if (parkingLot.Vehicles == null || parkingLot.Vehicles.All(x => x.Id != vehicle.Id))
{
throw new VehicleNotInParkingLotException(vehicle.RegistrationNumber);
}
var vehicleRecord = parkingLot.Vehicles.FirstOrDefault(x => x.Id == vehicle.Id);
return(CalculateHoursSpentInParking(parkingLot, vehicleRecord));
}
public static void UpdateEntity(this Data.Vehicle entity, VehicleViewModel model)
{
if (model == null || entity == null)
{
return;
}
entity.Id = model.Id;
entity.RegistrationNumber = model.RegistrationNumber;
entity.FirstRegistrationDate = model.FirstRegistrationDate.HasValue ? DateTime.SpecifyKind(model.FirstRegistrationDate.Value, DateTimeKind.Utc) : model.FirstRegistrationDate;
entity.Vin = model.Vin;
entity.EngineNumber = model.EngineNumber;
entity.VehicleType = model.VehicleType;
entity.Model = model.Model;
entity.TypeApprovalNumber = model.TypeApprovalNumber;
entity.ApprovalType = model.ApprovalType;
entity.TradeDescription = model.TradeDescription;
entity.Color = model.Color;
entity.Category = model.Category;
entity.OffRoadSymbols = model.OffRoadSymbols;
entity.MassG = model.MassG;
entity.MassF1 = model.MassF1;
entity.MassF2 = model.MassF2;
entity.MassF3 = model.MassF3;
entity.VehicleNumOfAxles = model.VehicleNumOfAxles;
entity.VehicleMassO1 = model.VehicleMassO1;
entity.VehicleMassO2 = model.VehicleMassO2;
entity.Capacity = model.Capacity;
entity.MaxPower = model.MaxPower;
entity.Fuel = model.Fuel;
entity.EnvironmentalCategory = model.EnvironmentalCategory;
entity.VehicleDocumentNumber = model.VehicleDocumentNumber;
entity.VehicleDocumentDate = model.VehicleDocumentDate.HasValue ? DateTime.SpecifyKind(model.VehicleDocumentDate.Value, DateTimeKind.Utc) : model.VehicleDocumentDate;
entity.VehicleOwner = new List <VehicleOwner>();
if (model.Owners != null && model.Owners.Any())
{
entity.VehicleOwner = model.Owners
.Select(x => x.ToEntity()).ToList();
}
entity.VehicleUser = new List <VehicleUser>();
entity.VehicleUser = model.Users
.Select(x => x.ToEntity()).ToList();
return;
}
public async Task <Data.Vehicle> AddOrUpdateVehicleAsync(VehicleViewModel model)
{
if (model == null)
{
throw new NullReferenceException("VehicleViewModel is null");
}
Data.Vehicle entity = null;
var existing = await _context.Vehicle
.Include(x => x.VehicleExtension)
.Include(x => x.VehicleOwner)
.Where(x => x.RegistrationNumber.ToLower() == model.RegistrationNumber.ToLower() &&
x.VehicleExtension != null &&
x.VehicleExtension.Deactivated == false)
.ToListAsync();
if (!existing.Any())
{
entity = model.ToEntity();
entity.Id = 0;
entity.VehicleExtension.VehicleId = entity.Id;
await _context.Vehicle.AddAsync(entity);
}
else
{
foreach (Data.Vehicle item in existing)
{
item.VehicleExtension.Deactivated = true;
_context.VehicleOwner.RemoveRange(item.VehicleOwner);
_context.VehicleUser.RemoveRange(item.VehicleUser);
}
existing[0].UpdateEntity(model);
existing[0].VehicleExtension.Deactivated = false;
existing[0].VehicleExtension.UpdatedAt = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Utc);
existing[0].VehicleExtension.RequestId = model.ExtensionRequestId;
_context.Vehicle.Update(existing[0]);
entity = existing[0];
}
await _context.SaveChangesAsync();
return(entity);
}
public void createvehicle(Client player, string OwnerType, string Name, VehicleHash hash, int color1, int color2)
{
AccountController account = player.getData("ACCOUNT");
if (account == null)
{
return;
}
if (!AdminController.AdminRankCheck("createvehicle", account))
{
return;
}
Data.Vehicle VehicleData = new Data.Vehicle();
if (OwnerType == "player")
{
AccountController TargetAccountController = AccountController.GetAccountControllerFromName(Name);
if (TargetAccountController == null)
{
return;
}
VehicleData.Character = TargetAccountController.CharacterController.Character;
}
else if (OwnerType == "group")
{
Groups.GroupController GroupController = EntityManager.GetGroup(player, Name);
VehicleData.Group = GroupController.Group;
}
else
{
API.sendChatMessageToPlayer(player, "~r~ERROR: ~w~You specified an invalid owner type (player/group");
return;
}
Vehicles.VehicleController VehicleController = new Vehicles.VehicleController(VehicleData, API.createVehicle(hash, player.position, player.rotation, color1, color2, 0));
VehicleData.Model = hash.GetHashCode();
VehicleData.PosX = player.position.X;
VehicleData.PosY = player.position.Y;
VehicleData.PosZ = player.position.Z;
VehicleData.Rot = player.rotation.Z;
VehicleData.Color1 = color1;
VehicleData.Color2 = color2;
ContextFactory.Instance.Vehicle.Add(VehicleData);
ContextFactory.Instance.SaveChanges();
}
public VehicleController(Data.Vehicle vehicleData, GTANetworkServer.Vehicle vehicle)
{
VehicleData = vehicleData;
Vehicle = vehicle;
API.setVehicleEngineStatus(vehicle, false); // Engine is always off.
if (vehicleData.JobId == JobsIdNonDataBase.BusDriver || vehicleData.Type == 1)
{
API.setVehicleLocked(vehicle, false); // Driver door is opened for Buses.
}
else
{
API.setVehicleDoorState(vehicle, 0, false); // Driver door is always closed.
API.setVehicleLocked(vehicle, true); // Driver door is always locked.
}
EntityManager.Add(this);
}
private async Task <Data.Vehicle> RegisterVehicleInDbAsync(Vehicle vehicle)
{
var categoryType = ValidateVehicleCategory(vehicle);
var cardType = ValidateCardType(vehicle);
var category = await vehicleCategoryRepository.FirstOrDefaultAsync(x => x.Type == categoryType);
var card = cardType == null ? null : await promotionCardRepository.FirstOrDefaultAsync(x => x.Type == cardType);
var vehicleDb = new Data.Vehicle()
{
RegistrationNumber = vehicle.RegistrationNumber,
Category = category,
PromotionCard = card
};
return(await vehicleRepository.InsertAsync(vehicleDb));
}
public async Task <HoursInParking> TryToUnregisterCar(Data.Vehicle vehicle)
{
var parkingLot = await Get();
if (parkingLot.Vehicles == null || parkingLot.Vehicles.All(x => x.Id != vehicle.Id))
{
throw new VehicleNotInParkingLotException(vehicle.RegistrationNumber);
}
// Prevent simultanious updates by applying simple concurrency control.
var record = parkingLot.Vehicles.FirstOrDefault(x => x.Id == vehicle.Id);
var removeVehicleFromParkingUpdate = MongoDB.Driver.Builders <Data.ParkingLot> .Update.Pull(x => x.Vehicles, record);
var vehicleRequiredSpace = vehicle.GetParkingSpace();
var result = CollectionUpdateResult.Conflict;
while (result == CollectionUpdateResult.Conflict)
{
var returnAvailableSpaceUpdate = MongoDB.Driver.Builders <Data.ParkingLot> .Update.Set(x => x.AvailableSpace, parkingLot.AvailableSpace + vehicleRequiredSpace);
result = await parkingLotRepository.UpdateConcurrentlyAsync(parkingLot, null, removeVehicleFromParkingUpdate, returnAvailableSpaceUpdate);
if (result == CollectionUpdateResult.Conflict)
{
// Simply reload parking with new data and try again.
parkingLot = await Get();
// Vehicle might have been removed by another request
if (parkingLot.Vehicles == null || parkingLot.Vehicles.All(x => x.Id != vehicle.Id))
{
throw new VehicleNotInParkingLotException(vehicle.RegistrationNumber);
}
}
else if (result == CollectionUpdateResult.Failed)
{
// Log error
break;
}
// Nothing to do on success
}
return(CalculateHoursSpentInParking(parkingLot, record));
}
/// <summary>
/// Initializes a new instance of the <see cref="Vehicle"/> class.
/// </summary>
/// <param name="vehicle">The vehicle.</param>
/// <param name="atPickup">When true, populates pickup damage info, when false, delivery.</param>
public Vehicle(Data.Vehicle vehicle, bool atPickup)
{
VIN = vehicle.Vin;
if (atPickup)
{
Damage = vehicle.DamageAtPickup.Select(d => new Damage(d)).ToList();
Photo = vehicle.Photos.Where(p => p.Url.Contains("CollectionDamage"))
.Select(p => new HostedDocument(p))
.ToList();
}
else
{
Damage = vehicle.DamageAtDropoff.Select(d => new Damage(d)).ToList();
Photo = vehicle.Photos.Where(p => p.Url.Contains("DeliveryDamage"))
.Select(p => new HostedDocument(p))
.ToList();
}
}
public static void UpdateEntity(this Data.Vehicle entity, RegiX.Client.ResponseModels.GetMotorVehicleRegistrationInfoV3ResponseTypeResponseResult model)
{
if (model == null || entity == null)
{
return;
}
entity.RegistrationNumber = model.VehicleData?.RegistrationNumber;
entity.FirstRegistrationDate = (model.VehicleData != null && model.VehicleData.FirstRegistrationDateSpecified) ? DateTime.SpecifyKind(model.VehicleData.FirstRegistrationDate, DateTimeKind.Utc) : default(DateTime?);
entity.Vin = model.VehicleData?.VIN;
entity.EngineNumber = model.VehicleData?.EngineNumber;
entity.VehicleType = model.VehicleData?.VehicleType;
entity.Model = model.VehicleData?.Model;
entity.TypeApprovalNumber = model.VehicleData?.TypeApprovalNumber;
entity.ApprovalType = model.VehicleData?.ApprovalType;
entity.TradeDescription = model.VehicleData?.TradeDescription;
entity.Color = model.VehicleData?.Color;
entity.Category = model.VehicleData?.Category;
entity.OffRoadSymbols = model.VehicleData?.OffRoadSymbols;
entity.MassG = model.VehicleData?.MassG;
entity.MassF1 = model.VehicleData?.MassF1;
entity.MassF2 = model.VehicleData?.MassF2;
entity.MassF3 = model.VehicleData?.MassF3;
entity.VehicleNumOfAxles = model.VehicleData?.VehNumOfAxles;
entity.VehicleMassO1 = model.VehicleData?.VehMassO1;
entity.VehicleMassO2 = model.VehicleData?.VehMassO2;
entity.Capacity = model.VehicleData?.Capacity;
entity.MaxPower = model.VehicleData?.MaxPower;
entity.Fuel = model.VehicleData?.Fuel;
entity.EnvironmentalCategory = model.VehicleData?.EnvironmentalCategory;
entity.VehicleDocumentNumber = model.VehicleData?.VehicleDocument?.VehDocumentNumber;
entity.VehicleDocumentDate = (model.VehicleData != null && model.VehicleData.VehicleDocument != null && model.VehicleData.VehicleDocument.VehDocumentDateSpecified) ?
DateTime.SpecifyKind(model.VehicleData.VehicleDocument.VehDocumentDate, DateTimeKind.Utc)
: default(DateTime?);
entity.VehicleOwner = CreateVehicleOwners(entity.Id, model);
entity.VehicleUser = CreateVehicleUsers(entity.Id, model);
return;
}
public static void RespawnWorkVehicle(Data.Vehicle vehicle, int vehicleModel, int vehicleCol1, int vehicleCol2)
{
var vehiclePosX = vehicle.PosX;
var vehiclePosY = vehicle.PosY;
var vehiclePosZ = vehicle.PosZ;
var vehicleRotZ = vehicle.Rot;
var vehicleController = EntityManager.GetVehicle(vehicle);
vehicleController.Vehicle.delete();
VehicleController newVehicle = new VehicleController(vehicle,
API.shared.createVehicle((VehicleHash)vehicle.Model,
new Vector3(vehiclePosX, vehiclePosY, vehiclePosZ),
new Vector3(0.0f, 0.0f, vehicleRotZ), vehicleCol1, vehicleCol2));
if (vehicle.Model == RentModels.TaxiModel)
{
vehicle.Character = null;
vehicle.RentTime = 0;
}
ContextFactory.Instance.SaveChanges();
}
public Data.Trip GetCurrentTrip(Data.Vehicle vehicle)
{
return(_fleetDbContext.Trips.Where((t, i) => t.VehicleId == vehicle.Id && t.EndTime != null).TakeLast(1).FirstOrDefault());
}
private decimal CalculatePaymentAmount(Data.Vehicle vehicleDb, HoursInParking timeSpentInParking)
{
var discount = vehicleDb.PromotionCard == null ? 0 : vehicleDb.PromotionCard.Discount;
return((timeSpentInParking.Daily * vehicleDb.Category.DailyCost + timeSpentInParking.Nightly * vehicleDb.Category.NightlyCost) * (1 - discount));
}
public void car(Client player, string Choice)
{
AccountController account = player.getData("ACCOUNT");
if (account == null)
{
return;
}
if (Choice == "engine")
{
VehicleController VehicleController = EntityManager.GetVehicle(player.vehicle);
if (VehicleController == null || player.vehicleSeat != -1)
{
API.sendChatMessageToPlayer(player, "~r~ERROR: ~w~You are not in a vehicle or on the driver's seat.");
return;
}
if (!VehicleController.CheckAccess(account))
{
API.sendNotificationToPlayer(player, "You cannot operate this vehicle.");
return;
}
else
{
if (API.getVehicleEngineStatus(VehicleController.Vehicle))
{
VehicleController.Vehicle.engineStatus = false;
ChatController.sendProxMessage(player, 15.0f, "~#C2A2DA~", account.CharacterController.FormatName + " turns the key in the ignition and the engine stops.");
}
else
{
VehicleController.Vehicle.engineStatus = true;
ChatController.sendProxMessage(player, 15.0f, "~#C2A2DA~", account.CharacterController.FormatName + " turns the key in the ignition and the engine starts.");
}
}
}
else if (Choice == "park")
{
VehicleController VehicleController = EntityManager.GetVehicle(player.vehicle);
Data.Vehicle VM = VehicleController.VehicleData;
if (VM == null || player.vehicleSeat != -1)
{
API.sendNotificationToPlayer(player, "~r~ERROR: ~w~You are not in a vehicle or on the driver's seat.");
return;
}
if (VehicleController.CheckAccess(account, account.CharacterController))
{
VehicleController.ParkVehicle(player);
}
else
{
API.sendNotificationToPlayer(player, "~r~ERROR: ~w~You cannot park this car.");
}
}
else if (Choice == "hood" || Choice == "trunk")
{
VehicleController VehicleController = null;
if (player.isInVehicle)
{
VehicleController = EntityManager.GetVehicle(player.vehicle);
}
else
{
VehicleController = EntityManager.GetVehicleControllers().Find(x => x.Vehicle.position.DistanceTo(player.position) < 3.0f);
}
if (VehicleController == null)
{
API.sendNotificationToPlayer(player, "You are not near a vehicle.");
return;
}
if (VehicleController.CheckAccess(account))
{
if (Choice == "hood")
{
VehicleController.TriggerDoor(VehicleController.Vehicle, 4);
}
else
{
VehicleController.TriggerDoor(VehicleController.Vehicle, 5);
}
}
else
{
API.sendNotificationToPlayer(player, "~r~ERROR: ~w~You cannot park this car.");
}
}
}
private async Task <List <Data.Vehicle> > SaveVehicles(MotorVehicleRegistrationResponse vehiclesResponse, long?messageId, PropertySearchRequestModel searchModel, bool useSearchIdentifier)
{
List <Data.Vehicle> newVehicles = new List <Data.Vehicle>();
List <Data.Vehicle> existingVehicles = new List <Data.Vehicle>();
foreach (RegiX.Client.ResponseModels.Vehicle vehicle in vehiclesResponse.Vehicles)
{
string regNumberToUse = vehicle.VehicleRegistrationNumber;
if (useSearchIdentifier)
{
regNumberToUse = searchModel.Identifier;
}
var existing = await _context.Vehicle
.Include(x => x.VehicleExtension)
.Include(x => x.VehicleOwner)
.Where(x => x.RegistrationNumber == regNumberToUse &&
x.VehicleExtension != null &&
x.VehicleExtension.Deactivated == false)
.ToListAsync();
if (!existing.Any())
{
Data.Vehicle entity = vehicle.ToEntity();
entity.RegistrationNumber = regNumberToUse;
entity.VehicleExtension = new VehicleExtension
{
VehicleId = entity.Id,
UpdatedAt = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Utc),
RequestId = messageId,
Deactivated = false
};
if (entity != null)
{
newVehicles.Add(entity);
}
}
else
{
foreach (Data.Vehicle item in existing)
{
item.VehicleExtension.Deactivated = true;
_context.VehicleOwner.RemoveRange(item.VehicleOwner);
}
existing[0].UpdateEntity(vehicle);
existing[0].RegistrationNumber = regNumberToUse;
existing[0].VehicleExtension.Deactivated = false;
existing[0].VehicleExtension.UpdatedAt = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Utc);
existing[0].VehicleExtension.RequestId = messageId;
existingVehicles.AddRange(existing);
}
}
if (newVehicles.Count > 0)
{
_context.Vehicle.AddRange(newVehicles);
}
if (existingVehicles.Count > 0)
{
_context.Vehicle.UpdateRange(existingVehicles);
}
await _context.SaveChangesAsync();
return(newVehicles.Concat(existingVehicles).ToList());
}
public async Task <bool> TryToRegisterCar(Data.Vehicle vehicle)
{
var parkingLot = await Get();
if (parkingLot.Vehicles != null && parkingLot.Vehicles.Any(x => x.Id == vehicle.Id))
{
throw new VehicleAlreadyInParkingLotException(vehicle.RegistrationNumber);
}
var vehicleRequiredSpace = vehicle.GetParkingSpace();
var record = new Data.VehicleRecord()
{
Id = vehicle.Id,
RegistrationDate = currentTimeProvider.Now(),
PromotionCard = vehicle.PromotionCard,
Category = vehicle.Category
};
// Prevent simultanious updates by applying simple concurrency control.
var addVehicleToParkingUpdate = MongoDB.Driver.Builders <Data.ParkingLot> .Update.AddToSet(x => x.Vehicles, record);
var result = CollectionUpdateResult.Conflict;
bool hasSpace = false;
while (result == CollectionUpdateResult.Conflict)
{
// Recalculate available space, because another request might have added another car
hasSpace = 0 <= parkingLot.AvailableSpace - vehicleRequiredSpace;
var takeAvailableSpaceUpdate = MongoDB.Driver.Builders <Data.ParkingLot> .Update.Set(x => x.AvailableSpace, parkingLot.AvailableSpace - vehicleRequiredSpace);
if (hasSpace)
{
if (parkingLot.Vehicles == null)
{
parkingLot.Vehicles = new List <Data.VehicleRecord>();
}
result = await parkingLotRepository.UpdateConcurrentlyAsync(parkingLot, null, addVehicleToParkingUpdate, takeAvailableSpaceUpdate);
if (result == CollectionUpdateResult.Conflict)
{
parkingLot = await Get();
// Vehicle might have been added by another request
if (parkingLot.Vehicles != null && parkingLot.Vehicles.Any(x => x.Id == vehicle.Id))
{
throw new VehicleAlreadyInParkingLotException(vehicle.RegistrationNumber);
}
}
else if (result == CollectionUpdateResult.Failed)
{
// Log error
hasSpace = false;
break;
}
// Nothing to do on success
}
else
{
// No need to try to put the vehicle in the parking if its already full.
break;
}
}
return(hasSpace);
}
public bool IsOnTrip(Data.Vehicle vehicle)
{
return(_fleetDbContext.Trips.Where((trip, i) => trip.VehicleId == vehicle.Id).TakeLast(1).Any(trip => trip.EndTime != null));
}
public static VehicleController GetVehicle(Data.Vehicle VehicleData)
{
return(_VehicleControllers.Find(x => x.VehicleData == VehicleData));;
}
