public Travel(Location source, Location destination, IEnumerable <Traveler> travelers)
{
this.Travelers = travelers;
this.SourceLocation = source;
this.Destination = destination;
this.Vehicle = VehicleFactory.getCorrectVehicleByTravel(this);
}
private Vehicle createNewVehicle(string i_UserPlateNumber)
{
bool isVehicleTypeValid = false;
Vehicle newVehicle;
VehicleFactory.eVehicleType newVehicleType = VehicleFactory.eVehicleType.FuelCar;
string userChoice;
Console.WriteLine("{0}Please Enter the following information: {0}", Environment.NewLine);
this.printMultiChoiceList(VehicleFactory.VehicleTypeKey, Enum.GetNames(typeof(VehicleFactory.eVehicleType)));
this.printEnterChoiceMsg();
do
{
try
{
userChoice = Console.ReadLine();
newVehicleType = LogicUtils.EnumValidation <VehicleFactory.eVehicleType>(userChoice, VehicleFactory.VehicleTypeKey);
isVehicleTypeValid = true;
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
}while (!isVehicleTypeValid);
newVehicle = VehicleFactory.CreateVehicle(i_UserPlateNumber, newVehicleType);
this.setVehicleInfo(newVehicle, newVehicleType);
return(newVehicle);
}
private Vehicle createNewVehicle(
string i_LicensePlate,
string i_ModelName,
string i_WheelManufacturer,
out string o_OwnerName,
out string o_OwnerPhone)
{
Vehicle newVehicle;
Vehicle.eTypeOfVehicle vehicleType, vehicleOptions = new Vehicle.eTypeOfVehicle();
EnergySource.eSourceType vehicleEnergySource;
EnergySource.eSourceType energySourceOptions = new EnergySource.eSourceType();
string PartOfOptionsHeaderMsg = string.Format("vehicle type");
o_OwnerName = UI.GetOwnerName();
o_OwnerPhone = UI.GetOwnerPhone();
vehicleType = (Vehicle.eTypeOfVehicle)UI.GetSpecificEnumInput(PartOfOptionsHeaderMsg, vehicleOptions);
PartOfOptionsHeaderMsg = string.Format("energy source");
if (vehicleType != Vehicle.eTypeOfVehicle.Truck)
{
vehicleEnergySource = (EnergySource.eSourceType)UI.GetSpecificEnumInput(PartOfOptionsHeaderMsg, energySourceOptions);
}
else
{
vehicleEnergySource = EnergySource.eSourceType.Gas;
}
newVehicle = VehicleFactory.CreateVehicle(vehicleType, vehicleEnergySource, i_LicensePlate, i_ModelName, i_WheelManufacturer);
insertVehicleDetails(newVehicle);
return(newVehicle);
}
public void TestMethod_Statistics()
{
IVehicleInventory inventory = new VehicleInventory();
var mfg = new Manufacturer("Toyota", "100 main", "800-999-9999");
var vehicle = VehicleFactory.CreateVehicle("vinnumber3", VehicleMake.Ford, "model", 2017, "yellow", 1500, 10000, 10000);
inventory.Add(vehicle);
vehicle = VehicleFactory.CreateVehicle("vinnumber1", VehicleMake.BMW, "model", 2016, "red", 2500, 60000, 60000);
inventory.Add(vehicle);
vehicle = VehicleFactory.CreateVehicle("vinnumber1", VehicleMake.Toyota, "model", 2016, "red", 2500, 20000, 20000);
inventory.Add(vehicle);
var vehicleList = inventory.List();
Assert.AreEqual(30000, vehicleList.AverageMSRP());
Assert.AreEqual(10000, vehicleList.MinMSRP());
Assert.AreEqual(60000, vehicleList.MaxMSRP());
Assert.AreEqual(30000, vehicleList.AverageMileage());
Assert.AreEqual(10000, vehicleList.MinMileage());
Assert.AreEqual(60000, vehicleList.MaxMileage());
Assert.AreEqual(3, vehicleList.CountDueForOilChange());
//do an oil change, then re-check count
vehicle.LastOilChangeDate = DateTime.Now;
vehicle.LastOilChangeMiles = 20000;
Assert.AreEqual(2, vehicleList.CountDueForOilChange());
}
public void CanUpdateVehicle()
{
var repo = VehicleFactory.GetVehicleRepository();
var vehicle = new Vehicle
{
MakeId = 2,
ModelId = 3,
ColorId = 3,
TransmitionId = 2,
InteriorId = 2,
Mileage = 50000,
VinNum = "56789",
Year = 2014,
Descrip = "One of the best prices on the lot!",
MSRP = 16000,
SalesPrice = 13000,
BodyStyleId = 2,
PictureFileName = "inventory-4.jpg",
IsSold = false,
IsFeatured = false,
IsNew = false
};
repo.InsertVehicle(vehicle);
vehicle.MSRP = 15000;
vehicle.MakeId = 3;
vehicle.ModelId = 3;
vehicle.ColorId = 2;
vehicle.TransmitionId = 1;
vehicle.InteriorId = 1;
vehicle.Mileage = 55000;
vehicle.VinNum = "12345";
vehicle.BodyStyleId = 1;
vehicle.PictureFileName = "inventory-5.jpg";
vehicle.IsFeatured = true;
vehicle.IsNew = true;
vehicle.SalesPrice = 13000;
vehicle.IsSold = true;
repo.UpdateVehicle(vehicle);
var updatedListing = repo.GetVehicleDetails(9);
Assert.AreEqual(15000, updatedListing.MSRP);
Assert.AreEqual(55000, updatedListing.Mileage);
Assert.AreEqual(13000, updatedListing.SalesPrice);
Assert.AreEqual(true, updatedListing.IsSold);
Assert.AreEqual("Toyota", updatedListing.MakeName);
Assert.AreEqual("Camry", updatedListing.ModelName);
Assert.AreEqual("Car", updatedListing.BodyStyle);
Assert.AreEqual("12345", updatedListing.VinNum);
Assert.AreEqual("inventory-5.jpg", updatedListing.PictureFileName);
Assert.AreEqual(true, updatedListing.IsNew);
Assert.AreEqual(true, updatedListing.IsFeatured);
Assert.AreEqual("Automatic", updatedListing.TransmitionType);
Assert.AreEqual("Black", updatedListing.InteriorType);
}
static void Main(string[] args)
{
// Honda
Honda honda = new Honda();
VehicleFactory vehicleFactoryHonda = new VehicleFactory(honda);
Bike hondaBike = vehicleFactoryHonda.GetBike();
Console.WriteLine(hondaBike.BikeName);
Car hondaCar = vehicleFactoryHonda.GetCar();
Console.WriteLine(hondaCar.CarName);
// Mercedes
Mercedes mercedes = new Mercedes();
VehicleFactory vehicleFactoryMercedes = new VehicleFactory(mercedes);
Bike MercedesBike = vehicleFactoryMercedes.GetBike();
Console.WriteLine(MercedesBike.BikeName);
Car MercedesCar = vehicleFactoryMercedes.GetCar();
Console.WriteLine(MercedesCar.CarName);
Console.ReadLine();
}
public IVehicle GetVehicle(string registrationNumber)
{
VehicleFactory factory = new VehicleFactory();
var dataBaseVehicle = dataContext.Vehicles.Where(o => o.RegistrationNumber == registrationNumber).FirstOrDefault();
if (dataBaseVehicle == null)
{
throw new Exception("No vehicle found in database");
}
var serviceIdList = GetServiceDatabaseIDListForVehicle(registrationNumber);
List <IService> serviceList = new List <IService>();
IService bookedService = null;
foreach (var id in serviceIdList)
{
var databaseService = dataContext.Services.Where(o => o.Id == id).Single();
if (databaseService.Completed == false)
{
bookedService = factory.CreateService(databaseService.Date.Date, databaseService.Description);
}
else
{
serviceList.Add(factory.CreateService(databaseService.Date.Date, databaseService.Description));
}
}
IVehicle vehicle = factory.CreateVehicle(dataBaseVehicle.RegistrationNumber, dataBaseVehicle.Model,
dataBaseVehicle.Brand, dataBaseVehicle.Weight,
(DateTime)dataBaseVehicle.FirstTimeInTraffic,
dataBaseVehicle.IsRegistered, bookedService, serviceList);
return(vehicle);
}
public async Task <IActionResult> UpdateVehicle(CreateVehicleRequestModel createVehicleRequestModel)
{
if (createVehicleRequestModel.VehicleId < 0)
{
return(BadRequest());
}
if (createVehicleRequestModel.RaceId < 0)
{
return(BadRequest());
}
var vehicleDto = VehicleFactory.CreateVehicle(createVehicleRequestModel);
if (vehicleDto == null)
{
return(BadRequest());
}
var result = await raceService.UpdateVehicle(vehicleDto);
if (!result.ResultInfo.IsOk)
{
return(Conflict(result.ResultInfo.Error));
}
return(Ok());
}
public static void Main()
{
var car = VehicleFactory.GetNew(Console.ReadLine().SplitToLower(" "));
var truck = VehicleFactory.GetNew(Console.ReadLine().SplitToLower(" "));
var bus = VehicleFactory.GetNew(Console.ReadLine().SplitToLower(" "));
var commandsCount = int.Parse(Console.ReadLine());
for (int count = 0; count < commandsCount; count++)
{
var input = Console.ReadLine().SplitToLower(" ");
if (input.Contains("car"))
{
car.ExecuteCommand(input);
}
else if (input.Contains("bus"))
{
bus.ExecuteCommand(input);
}
else
{
truck.ExecuteCommand(input);
}
}
Console.WriteLine(car.ToString());
Console.WriteLine(truck.ToString());
Console.WriteLine(bus.ToString());
}
public void Make_Returns_Camaro_Factory()
{
VehicleFactory vehicleFactory = new VehicleFactory();
IVehicle vehicle = vehicleFactory.Make(VehicleType.Camaro);
Assert.IsInstanceOfType(vehicle, typeof(CamaroVehicle));
}
public Collection <T> Select()
{
RouteFactory routeFactory = new RouteFactory();
RouteTable <Route> instanceRoute = (RouteTable <Route>)routeFactory.GetRouteInstance();
DriverFactory driverFactory = new DriverFactory();
DriverTable <Driver> instanceDriver = (DriverTable <Driver>)driverFactory.GetDriverInstance();
VehicleFactory vehicleFactory = new VehicleFactory();
VehicleTable <Vehicle> instanceVehicle = (VehicleTable <Vehicle>)vehicleFactory.GetVehicleInstance();
XDocument xDoc = XDocument.Load(Configuration.XMLFILEPATH);
Collection <T> timetables = new Collection <T>();
List <XElement> elements = xDoc.Descendants("Timetables").Descendants("Timetable").ToList();
foreach (var element in elements)
{
Timetable timetable = new Timetable();
timetable.id = int.Parse(element.Attribute("id").Value);
timetable.name = element.Attribute("name").Value;
timetable.departure = DateTime.Parse(element.Attribute("departure").Value);
timetable.arrival = DateTime.Parse(element.Attribute("arrival").Value);
timetable.route = instanceRoute.Select(int.Parse(element.Attribute("routeId").Value));
timetable.driver = instanceDriver.Select(int.Parse(element.Attribute("driverId").Value));
timetable.vehicle = instanceVehicle.Select(int.Parse(element.Attribute("vehicleId").Value));
timetables.Add((T)timetable);
}
return(timetables);
}
// GET: Security/Vehicle
public ActionResult Index()
{
var vehicles = _dbContext.Vehicles.ToList()
.Select(g => VehicleFactory.VehicleEntityToViwModel(g));
return(View(vehicles));
}
private IList <Vehicle> MathSolutionInOneGo(IList <Vehicle> vehicless, DateTime momentSized, DateTime raceStartedAt, int raceDistanc)
{
var vehicles = vehicless.ToList();
// Move vehicles
foreach (var vehicle in vehicles.Where(x => !x.IsDNF && !x.FinishedAt.HasValue))
{
var moreInfo = VehicleFactory.GetVehicleStaticProps(vehicle.Type, vehicle.SubType);
var idealTimeToFinishRace = raceDistanc / moreInfo.MaxSpeed;
var chancesNotToDNF = idealTimeToFinishRace * ((100 - moreInfo.HeavyMalfunction) / 100);
var isDNF = InversePoisson(chancesNotToDNF);
if (isDNF < moreInfo.HeavyMalfunction)
{
vehicle.IsDNF = true;
vehicle.ModifiedAt = momentSized;
continue;
}
var chancesNotToMalfunction = idealTimeToFinishRace * ((100 - moreInfo.LightMalfunction) / 100);
var malfunctionOccurrenc = Math.Round(InversePoisson(chancesNotToMalfunction));
var timeFixing = malfunctionOccurrenc * moreInfo.RepairmentsLast;
vehicle.FinishedAt = raceStartedAt.AddHours(idealTimeToFinishRace + timeFixing);
vehicle.NumberOfLightMalfunction = (int)malfunctionOccurrenc;
vehicle.Millage = raceDistanc;
}
return(vehicles);
}
public IVehicle GetVehicleDetail(int vehicleId, int vehicleTypeId)
{
var vehicleFactory = VehicleFactory.LoadFactory(vehicleTypeId);
var vehicleViewModel = vehicleFactory.CreateVehicle(vehicleId);
return(vehicleViewModel);
}
private IVehicle CreateVehicleFromDto(VehicleRequestDto vehicleRequestDto)
{
var factory = new VehicleFactory();
IList <IService> vehicleServices = new List <IService>();
foreach (var service in vehicleRequestDto.ServiceHistory)
{
vehicleServices.Add(factory.CreateService(service.ServiceDate, service.ServiceHistory));
}
IService isServiceBooked = null;
if (vehicleRequestDto.IsServiceBooked != null)
{
isServiceBooked = factory.CreateService(vehicleRequestDto.IsServiceBooked.ServiceDate,
vehicleRequestDto.IsServiceBooked.ServiceHistory);
}
IVehicle vehicle = factory.CreateVehicle(vehicleRequestDto.RegNumber, vehicleRequestDto.Model,
vehicleRequestDto.Make, vehicleRequestDto.VehicleWeight,
vehicleRequestDto.FirstDateInTraffic, vehicleRequestDto.IsRegistered,
isServiceBooked, (IList <IVehicleService>)vehicleServices);
return(vehicle);
}
private List <string> getVehicleParametersFromUser(string i_VehicleLicenseNumber)
{
VehicleFactory.eVehicleType vehicleType = this.getVehicleType();
List <string> vehicleParameters =
new List <string>
{
vehicleType.ToString(),
this.getRegularParameterDetails(
@"Please insert the vehicle's model name.",
ParameterChecker.eExpectedInputType.All),
i_VehicleLicenseNumber,
this.getRangeParametersDetails(
@"Please insert how much energy \ fuel left (0 to 100%) in the vehicle.",
k_MinValue,
Utilities.k_MaxPercentage),
this.getRegularParameterDetails(
"Please type the tires' manufacture name.",
ParameterChecker.eExpectedInputType.All),
this.getRangeParametersDetails(
"Please enter the vehicle's current tire's air pressure.",
k_MinValue,
Vehicle.GetMaxAirPressure(vehicleType))
};
List <ParameterChecker> extraParameterInfo = VehicleFactory.BuildExtraParametersInfo(vehicleType);
this.getExtraVehicleParameters(vehicleParameters, extraParameterInfo);
return(vehicleParameters);
}
public void CreateVehicle()
{
VehicleRequirements requirements = new VehicleRequirements();
requirements.NumberOfWheels = Mathf.Max(NumberOfWheels, 1);
requirements.Engine = Engine;
requirements.Passengers = Mathf.Max(Passengers);
if (Cargo != false)
{
requirements.Engine = Cargo;
}
requirements.HasCargo = Cargo;
requirements.canFly = CanFly;
VehicleFactory factory = new VehicleFactory(requirements);
IVehicle v = factory.Create();
if (ornament)
{
v = new WithOrnament(v);
}
if (missles)
{
v = new WithMissles(v);
}
if (airFreshener)
{
v = new WithAirFreshener(v);
}
Debug.Log(v.GetName());
}
public void CanLoadVehicleDetails()
{
var repo = VehicleFactory.GetVehicleRepository();
var vehicle = repo.GetVehicleDetails(1);
Assert.IsNotNull(vehicle);
Assert.IsNotNull(vehicle);
Assert.AreEqual("Taurus", vehicle.ModelName);
Assert.AreEqual("Ford", vehicle.MakeName);
Assert.AreEqual("Blue", vehicle.ColorType);
Assert.AreEqual("Automatic", vehicle.TransmitionType);
Assert.AreEqual("Black", vehicle.InteriorType);
Assert.AreEqual(20000, vehicle.Mileage);
Assert.AreEqual("12345", vehicle.VinNum);
Assert.AreEqual(2010, vehicle.Year);
Assert.AreEqual("A Wonderful car with a few cosmetic issues", vehicle.Descrip);
Assert.AreEqual(12000, vehicle.MSRP);
Assert.AreEqual(10000, vehicle.SalesPrice);
Assert.AreEqual("Car", vehicle.BodyStyle);
Assert.AreEqual("inventory-1.jpg", vehicle.PictureFileName);
Assert.AreEqual(false, vehicle.IsNew);
Assert.AreEqual(false, vehicle.IsDeleted);
}
/// <summary>
/// add new truck method
/// </summary>
private static void addNewTruck()
{
try
{
bool hezerdosMat = false;
Console.WriteLine("the truck carry hezerdos matirials? (yes or no)");
string answer = Console.ReadLine();
if (answer.StartsWith("y") || answer.StartsWith("Y"))
{
hezerdosMat = true;
}
else
{
hezerdosMat = false;
}
float maxWeight = Utils.Parsers.GetFloatFromUser("Enter truck max weight:");
float currentAmount;
string vehicleModel;
string vehicleLicensePlate;
string ownerName;
string ownerPhone;
string wheelManufacturerName;
Utils.Parsers.RefBasicVehicleDetails(out currentAmount, out vehicleModel, out vehicleLicensePlate,
out ownerName, out ownerPhone, out wheelManufacturerName);
GarageLogic.GarageLogic.GarageDirectory.Add(vehicleLicensePlate, VehicleFactory.CreateNewFuelTruck(currentAmount, hezerdosMat,
maxWeight, vehicleModel, vehicleLicensePlate, ownerName, ownerPhone, wheelManufacturerName));
}
catch (FormatException ex)
{
Console.WriteLine(ex.Message + "Can`t parse Truck!");
}
}
public void CanInsertVehicle()
{
var repo = VehicleFactory.GetVehicleRepository();
var vehicle = new Vehicle
{
MakeId = 2,
ModelId = 3,
ColorId = 3,
TransmitionId = 2,
InteriorId = 2,
Mileage = 50000,
VinNum = "56789",
Year = 2014,
Descrip = "One of the best prices on the lot!",
MSRP = 15000,
SalesPrice = 13000,
BodyStyleId = 2,
PictureFileName = "inventory-4.jpg",
IsSold = false,
IsFeatured = false,
IsNew = false
};
repo.InsertVehicle(vehicle);
Assert.AreEqual(9, vehicle.VehicleId);
}
public void TestMethod_OilChange()
{
IVehicleInventory inventory = new VehicleInventory();
var mfg = new Manufacturer("Subaru", "100 main", "800-999-9999");
var vehicle = VehicleFactory.CreateVehicle("vinnumber3", VehicleMake.Subaru, "Impreza", 2017, "yellow", 1500, 2500, 10000);
vehicle.LastOilChangeDate = new DateTime(2016, 10, 1);
vehicle.LastOilChangeMiles = 1000;
Assert.IsTrue(vehicle.IsDueForOilChange());
vehicle.LastOilChangeMiles = 10000;
vehicle.LastOilChangeDate = DateTime.Now;
Assert.IsFalse(vehicle.IsDueForOilChange());
vehicle = VehicleFactory.CreateVehicle("vinnumberVW", VehicleMake.Volkswagen, "Jetta", 2017, "yellow", 1500, 2500, 10000);
vehicle.LastOilChangeDate = new DateTime(2016, 10, 1);
vehicle.LastOilChangeMiles = 2100;
Assert.IsFalse(vehicle.IsDueForOilChange());
vehicle = VehicleFactory.CreateVehicle("vinnumbertesla", VehicleMake.Tesla, "Models", 2017, "yellow", 1500, 2500, 10000);
Assert.IsFalse(vehicle.IsDueForOilChange());
vehicle = VehicleFactory.CreateVehicle("vinnumbertoyota", VehicleMake.Toyota, "4runner", 2017, "yellow", 1500, 2500, 10000);
Assert.IsTrue(vehicle.IsDueForOilChange());
vehicle.LastOilChangeDate = new DateTime(2017, 1, 1);
vehicle.LastOilChangeMiles = 11000;
Assert.IsFalse(vehicle.IsDueForOilChange());
// alternative - use separate class to check for oil change
var dueForOilChange = OilChangeRules.IsDueForOilChange(vehicle);
Assert.IsFalse(dueForOilChange);
}
private static void DemoVehicleInventory()
{
IVehicleInventory inventory = new VehicleInventory();
var vehicle = VehicleFactory.CreateVehicle("vinnumber3", VehicleMake.Tesla, "Model S", 2017, "yellow", 1500, 2500, 100);
//var temp = vehicle.Mfg;
inventory.Add(vehicle);
vehicle = VehicleFactory.CreateVehicle("vinnumber1", VehicleMake.BMW, "325i", 2016, "red", 2500, 4000, 100);
inventory.Add(vehicle);
inventory.Remove(vehicle);
inventory.Add(vehicle);
var v1 = inventory.List(SortOrder.Vin);
Console.WriteLine("List of Vehicles");
v1.ForEach(v => Console.WriteLine($"{v.VinNumber}, {v.Make}, {v.Model}"));
var v2 = inventory.FindByYear(2017);
var v3 = inventory.List(SortOrder.Vin).FindByMake(VehicleMake.BMW);
v3.AddToMileage(99);
var v3_1 = inventory.List().FindByMake(VehicleMake.BMW);
var v4 = inventory.List().FindByMake(VehicleMake.Ford);
var stringList = inventory.ListAsString(SortOrder.Vin);
Console.WriteLine("List of Vehicles - in Json(string) format");
Console.WriteLine($"{stringList}");
}
/// <summary>
/// Select the record for a name.
/// </summary>
//public Timetable SelectForName(string pName, Database pDb = null)
//{
// Database db;
// if (pDb == null)
// {
// db = new Database();
// db.Connect();
// }
// else
// {
// db = pDb;
// }
// SqlCommand command = db.CreateCommand(SQL_SELECT_NAME);
// command.Parameters.AddWithValue("@name", pName);
// SqlDataReader reader = db.Select(command);
// Collection<Timetable> timeTables = Read(reader);
// Timetable v = null;
// if (timeTables.Count == 1)
// {
// v = timeTables[0];
// }
// reader.Close();
// if (pDb == null)
// {
// db.Close();
// }
// return v;
//}
private Collection <T> Read(SqlDataReader reader)
{
RouteFactory routeFactory = new RouteFactory();
RouteTable <Route> instanceRoute = (RouteTable <Route>)routeFactory.GetRouteInstance();
VehicleFactory vehicleFactory = new VehicleFactory();
var instanceVehicle = vehicleFactory.GetVehicleInstance();
DriverFactory driverFactory = new DriverFactory();
DriverTable <Driver> instanceDriver = (DriverTable <Driver>)driverFactory.GetDriverInstance();
Collection <T> timeTables = new Collection <T>();
while (reader.Read())
{
Timetable timeTable = new Timetable();
int i = -1;
timeTable.id = reader.GetInt32(++i);
timeTable.name = reader.GetString(++i);
timeTable.departure = reader.GetDateTime(++i);
timeTable.arrival = reader.GetDateTime(++i);
var idRoute = reader.GetInt32(++i);
var idDriver = reader.GetInt32(++i);
var idVehicle = reader.GetInt32(++i);
timeTable.route = instanceRoute.Select(idRoute);
timeTable.vehicle = instanceVehicle.Select(idVehicle);
timeTable.driver = instanceDriver.Select(idDriver);
timeTables.Add((T)timeTable);
}
return(timeTables);
}
private static void insertNewVehicleToGarage(string i_LicensePlate, GarageLogic i_MyGarage, string i_OwnerName, string i_OwnerPhoneNumber)
{
string vehicleTypeToInsert = getFromUserTypeOfVehicle();
try
{
Vehicle vehicleToAdd = VehicleFactory.CreateVehicle(vehicleTypeToInsert, i_LicensePlate);
List <string> vehicleSpecsNeeded = vehicleToAdd.GetsSpecs();
getInformationFromUserAboutTheVehicle(vehicleSpecsNeeded, vehicleToAdd);
Record recordToAdd = new Record(i_OwnerName, i_OwnerPhoneNumber, vehicleToAdd);
i_MyGarage.AddVehicleToGarageRecords(recordToAdd);
}
catch (ArgumentException exception)
{
Console.Clear();
Console.WriteLine(exception.Message);
insertNewVehicleToGarage(i_LicensePlate, i_MyGarage, i_OwnerName, i_OwnerPhoneNumber);
}
catch (ValueOutOfRangeException exception)
{
Console.Clear();
Console.WriteLine(exception.Message);
insertNewVehicleToGarage(i_LicensePlate, i_MyGarage, i_OwnerName, i_OwnerPhoneNumber);
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
Console.Clear();
}
public Vehicle Get(int id)
{
VehicleFactory vehicleFactory = new VehicleFactory();
var instanceVehicle = vehicleFactory.GetVehicleInstance();
return(instanceVehicle.Select(id));
}
public string Post([FromBody] Vehicle obj)
{
SessionFactory sessionsFactory = new SessionFactory();
SessionsTable <Session> instance = (SessionsTable <Session>)sessionsFactory.GetSessionInstance();
var list = Request.Headers.ToList();
var token = list.Where(a => a.Key == "token")?.FirstOrDefault().Value.FirstOrDefault()?.Replace("\"", string.Empty);
if (token == null)
{
return("NOT LOGED");
}
var dispatcher = instance.SelectDispatcherSession(token);
var driver = instance.SelectDriverSession(token);
var manager = instance.SelectManagerSession(token);
if (dispatcher == null && driver == null && manager == null)
{
return("NOT EXISTING USER");
}
else if (obj == null)
{
return("NO OBJECT");
}
VehicleFactory vehicleFactory = new VehicleFactory();
var instanceVehicle = vehicleFactory.GetVehicleInstance();
instanceVehicle.Insert(obj);
return("OK");
}
public IEnumerable <Vehicle> Get()
{
SessionFactory sessionFactory = new SessionFactory();
var instanceSession = sessionFactory.GetSessionInstance();
VehicleFactory vehicleFactory = new VehicleFactory();
var instanceVehicle = vehicleFactory.GetVehicleInstance();
var list = Request.Headers.ToList();
var token = list.Where(a => a.Key == "token")?.FirstOrDefault().Value.FirstOrDefault()?.Replace("\"", string.Empty);
if (token == null)
{
return(new List <Vehicle>());
}
var dispatcher = instanceSession.SelectDispatcherSession(token);
var driver = instanceSession.SelectDriverSession(token);
var manager = instanceSession.SelectManagerSession(token);
if (dispatcher == null && driver == null && manager == null)
{
return(new List <Vehicle>());
}
else
{
return(instanceVehicle.Select());
}
}
public IVehicle GetVehicle(string regNumber)
{
VehicleFactory factory = new VehicleFactory();
var dbVehicle = dataContext.Vehicles.Where(o => o.RegNumber == regNumber).FirstOrDefault();
if (dbVehicle == null)
{
throw new Exception("No vehicle with that Registration number found in the database");
}
var dbVehicleServiceList = dataContext.VehicleServices.Where(o => o.RegNumber == regNumber);
var serviceIdList = dbVehicleServiceList.Select(o => o.Id);
List <IVehicleService> serviceList = new List <IVehicleService>();
IService isServiceBooked = null;
foreach (var id in serviceIdList)
{
var dbService = dataContext.VehicleServices.Where(o => o.Id == id).Single();
if (dbService.IsServiceBooked == false)
{
isServiceBooked = factory.CreateService(dbService.ServiceDate, dbService.ServiceHistory);
}
serviceList.Add((IVehicleService)factory.CreateService(dbService.ServiceDate, dbService.ServiceHistory));
}
IVehicle vehicle = factory.CreateVehicle(dbVehicle.RegNumber, dbVehicle.Model,
dbVehicle.Make, dbVehicle.VehicleWeight,
(DateTime)dbVehicle.FirstDateInTraffic,
dbVehicle.IsRegistered, isServiceBooked, serviceList);
return(vehicle);
}
public IEnumerator VehicleEngineDestroyTest()
{
yield return(null);
DisableLoops();
VehicleFactory vehicleFactory = (VehicleFactory)GameObject.FindObjectOfType(typeof(VehicleFactory));
foreach (TrafficLight trafficLight in TrafficLightManager.GetInstance().trafficLights)
{
trafficLight.SetColour(TrafficLight.LightColour.GREEN);
}
Rigidbody vehicle = vehicleFactory.SpawnVehicle(vehicleFactory.GetRandomVehicle(), vehicleFactory.GetRandomUnusedPath());
bool carIsDestroyed = false;
for (int i = 0; i <= TIME_OUT_DESTROY_TIME; i = i + 5)
{
yield return(new WaitForSeconds(5));
if (vehicle == null)
{
carIsDestroyed = true;
break;
}
}
Assert.True(carIsDestroyed);
}
public IEnumerator VehicleEngineSetStatusTest()
{
yield return(null);
DisableLoops();
VehicleFactory vehicleFactory = (VehicleFactory)GameObject.FindObjectOfType(typeof(VehicleFactory));
Rigidbody vehicle = vehicleFactory.SpawnVehicle(vehicleFactory.GetRandomVehicle(), vehicleFactory.GetRandomUnusedPath());
VehicleEngine vehicleEngine = vehicle.GetComponent <VehicleEngine>();
vehicleEngine.SetEngineStatus(VehicleEngine.EngineStatus.ACCELERATE);
Assert.AreEqual(0, vehicleEngine.wheelColliderFrontLeft.brakeTorque);
Assert.AreEqual(0, vehicleEngine.wheelColliderFrontRight.brakeTorque);
Assert.AreEqual(vehicleEngine.currentMotorTorque, vehicleEngine.wheelColliderFrontLeft.motorTorque);
Assert.AreEqual(vehicleEngine.currentMotorTorque, vehicleEngine.wheelColliderFrontRight.motorTorque);
vehicleEngine.SetEngineStatus(VehicleEngine.EngineStatus.STOP);
Assert.AreEqual(vehicleEngine.normalBrakeTorque, vehicleEngine.wheelColliderFrontLeft.brakeTorque);
Assert.AreEqual(vehicleEngine.normalBrakeTorque, vehicleEngine.wheelColliderFrontRight.brakeTorque);
Assert.AreEqual(0, vehicleEngine.wheelColliderFrontLeft.motorTorque);
Assert.AreEqual(0, vehicleEngine.wheelColliderFrontRight.motorTorque);
vehicleEngine.SetEngineStatus(VehicleEngine.EngineStatus.HARD_STOP);
Assert.AreEqual(vehicleEngine.maxBrakeTorque, vehicleEngine.wheelColliderFrontLeft.brakeTorque);
Assert.AreEqual(vehicleEngine.maxBrakeTorque, vehicleEngine.wheelColliderFrontRight.brakeTorque);
Assert.AreEqual(0, vehicleEngine.wheelColliderFrontLeft.motorTorque);
Assert.AreEqual(0, vehicleEngine.wheelColliderFrontRight.motorTorque);
}
public ActionResult buildVehicle(string make, string model, string color, int numDoors, string[] options = string[0])
{
VehicleFactory factory = new VehicleFactory();
Vehicle vehicle = factory.buildVehicle(make, model, color, numDoors, options);
// Save.
this.vehicleContext.Attach(vehicle);
this.vehicleContext.SaveAll();
// Display our newly created vehicle.
return View("BuildVehicle", vehicle);
}
