private Engine createEngine(eVehicleType i_VehicleType)
{
Engine engine = null;
switch (i_VehicleType)
{
case eVehicleType.ElectricCar:
engine = new ElectricEngine(k_ElectricCarMaxHours);
break;
case eVehicleType.ElectricMotorcycle:
engine = new ElectricEngine(k_ElectricMotorcycleMaxHours);
break;
case eVehicleType.FuelBasedCar:
engine = new FuelEngine(k_CarFuelType, k_CarMaxFuel);
break;
case eVehicleType.FuelBasedMotorcycle:
engine = new FuelEngine(k_MotorCycleFuelType, k_MotorcycleMaxFuel);
break;
case eVehicleType.FuelBasedTruck:
engine = new FuelEngine(k_TruckFuelType, k_TruckMaxFuel);
break;
}
return(engine);
}
public bool FillFuelToMax(Vehicle i_VehicleToActOn, eEngineType i_EngineTypeBasedOnMethodUse, eFuelType i_TypeOfFuelToAdd, float i_AmountOfFuel)
{
bool resultOfFuel = false;
switch (i_EngineTypeBasedOnMethodUse)
{
case eEngineType.Fuel:
FuelEngine currentFuelEngine = m_VehicleInGarage.VehicleEngine as FuelEngine;
resultOfFuel = currentFuelEngine.ChargeEnergyIfPossible(i_AmountOfFuel, i_TypeOfFuelToAdd);
break;
case eEngineType.Electric:
ElectricEngine currentElectricEngine = m_VehicleInGarage.VehicleEngine as ElectricEngine;
resultOfFuel = currentElectricEngine.ChargeEnergyIfPossible(i_AmountOfFuel);
break;
}
if (resultOfFuel)
{
i_VehicleToActOn.PercentOfEnergyLeft = 100;
i_VehicleToActOn.VehicleEngine.CurrentAmountOfEnergy = i_VehicleToActOn.VehicleEngine.MaxAmountOfEnergy;
}
return(resultOfFuel);
}
private static FuelCar initNewFuelCar(string i_LicensePlateSrting, string i_VehicleModel, float i_EnergyLeft, string i_WheelManufacturer, float i_WheelCurrentAirPressure, string[] i_Parameters)
{
const bool v_IgnoreCase = true;
const FuelEngine.eFuelType k_SupportedCarFuelType = FuelEngine.eFuelType.Octan96;
const float k_MaxCarFuelTank = 35;
if (i_EnergyLeft > k_MaxCarFuelTank)
{
throw new ValueOutOfRangeException(k_MaxCarFuelTank);
}
FuelEngine engine = new FuelEngine(k_MaxCarFuelTank, i_EnergyLeft, null, k_SupportedCarFuelType);
if (i_WheelCurrentAirPressure > k_MaxAirPressureInCarWheels)
{
throw new ValueOutOfRangeException(k_MaxAirPressureInCarWheels);
}
List <Wheel> wheels = new List <Wheel>(k_NumberOfWheelsInCar);
for (int i = 0; i < k_NumberOfWheelsInCar; i++)
{
wheels.Add(new Wheel(i_WheelManufacturer, i_WheelCurrentAirPressure, k_MaxAirPressureInCarWheels));
}
Car.eCarColor color = (Car.eCarColor)Enum.Parse(typeof(Car.eCarColor), i_Parameters[0], v_IgnoreCase);
Car.eNumOfDoors numOfDoors = (Car.eNumOfDoors)Enum.Parse(typeof(Car.eNumOfDoors), i_Parameters[1], v_IgnoreCase);
return(new FuelCar(i_LicensePlateSrting, i_VehicleModel, wheels, engine, color, numOfDoors));
}
public bool FuelVehicle(string i_PlateNumber, float i_Amount, FuelEngine.eFuelType i_Type)
{
bool isFueled = false;
GarageCustomer customer = FindCustomerByPlateNumber(i_PlateNumber);
if (customer != null)
{
IEngine engine = customer.Vehicle.Engine;
if (engine.EngineType() == typeof(FuelEngine))
{
FuelEngine fuelEngine = (FuelEngine)engine;
if (i_Type.Equals(fuelEngine.FuelType))
{
isFueled = fuelEngine.PutGas(i_Amount);
}
else
{
throw new ArgumentException("Wrong type of fuel");
}
}
else
{
throw new ArgumentException("Trying to put gas in an electric engine");
}
}
return(isFueled);
}
public virtual Dictionary <string, string> GetDetails()
{
Dictionary <string, string> vehicleDetails = new Dictionary <string, string>();
vehicleDetails.Add("Owner name", OwnerInfo.OwnerOfVehicleName);
vehicleDetails.Add("Owner phone number", OwnerInfo.OwnerPhoneNumber);
vehicleDetails.Add("License number", m_LicenseNumber);
vehicleDetails.Add("Model name", m_ModelName);
FuelEngine thisFuelEngine = m_VehicleEngine as FuelEngine;
if (thisFuelEngine != null)
{
vehicleDetails.Add("Engine type", "Fuel engine");
vehicleDetails.Add("Fuel capacity", m_VehicleEngine.MaxEnergyCapacity.ToString("F"));
vehicleDetails.Add("Current amount of fuel", m_VehicleEngine.CurrentEnergyCapacity.ToString("F"));
vehicleDetails.Add("Fuel type", thisFuelEngine.GasType.ToString());
}
else
{
vehicleDetails.Add("Engine type", "Electric engine");
vehicleDetails.Add("Battery capacity", m_VehicleEngine.MaxEnergyCapacity.ToString("F"));
vehicleDetails.Add("Current amount of battery", m_VehicleEngine.CurrentEnergyCapacity.ToString("F"));
}
vehicleDetails.Add("Vehicle status", m_VehicleStatus.ToString());
vehicleDetails.Add("Wheels manufacturer", m_WheelsList[0].ManufacturerName);
vehicleDetails.Add("Number of Wheels", m_WheelsList.Count.ToString());
vehicleDetails.Add("Maximum PSI", m_WheelsList[0].MaximalPsi.ToString("F"));
vehicleDetails.Add("Current PSI", m_WheelsList[0].CurrentPsi.ToString("F"));
return(vehicleDetails);
}
private static FuelMotorcycle initNewFuelMotorcycle(string i_LicensePlateSrting, string i_VehicleModel, float i_EnergyLeft, string i_WheelManufacturer, float i_WheelCurrentAirPressure, string[] i_Parameters)
{
const bool v_IgnoreCase = true;
const float k_MaxAirPressureInFuelMotorcycleWheels = 34;
const FuelEngine.eFuelType k_SupportedMotorcycleFuelType = FuelEngine.eFuelType.Octan98;
const float k_MaxMotorcycleFuelTank = 8;
if (i_EnergyLeft > k_MaxMotorcycleFuelTank)
{
throw new ValueOutOfRangeException(k_MaxMotorcycleFuelTank);
}
int engineVolume = int.Parse(i_Parameters[1]);
FuelEngine engine = new FuelEngine(k_MaxMotorcycleFuelTank, i_EnergyLeft, engineVolume, k_SupportedMotorcycleFuelType);
if (i_WheelCurrentAirPressure > k_MaxAirPressureInFuelMotorcycleWheels)
{
throw new ValueOutOfRangeException(k_MaxAirPressureInFuelMotorcycleWheels);
}
List <Wheel> wheels = new List <Wheel>(k_NumberOfWheelsInMotorcycle);
for (int i = 0; i < k_NumberOfWheelsInMotorcycle; i++)
{
wheels.Add(new Wheel(i_WheelManufacturer, i_WheelCurrentAirPressure, k_MaxAirPressureInFuelMotorcycleWheels));
}
Motorcycle.eLicenseType licenseType = (Motorcycle.eLicenseType)Enum.Parse(typeof(Motorcycle.eLicenseType), i_Parameters[0], v_IgnoreCase);
return(new FuelMotorcycle(i_LicensePlateSrting, i_VehicleModel, wheels, licenseType, engine));
}
protected virtual List <string> RequiredInfoForCreationOfVehicle()
{
List <string> engineInformation;
if (r_Engine is ElectricEngine)
{
ElectricEngine electricEngine = r_Engine as ElectricEngine;
engineInformation = electricEngine.RequiredInfoForCreation();
}
else
{
FuelEngine fuelEngine = r_Engine as FuelEngine;
engineInformation = fuelEngine.RequiredInfoForCreation();
}
List <string> wheelsInformation = m_Wheels[0].RequiredInfoForCreation();
List <string> requiredInfo = new List <string>();
requiredInfo.Add("Please enter vehicle MODEL NAME:");
foreach (string info in engineInformation)
{
requiredInfo.Add(info);
}
foreach (string info in wheelsInformation)
{
requiredInfo.Add(info);
}
return(requiredInfo);
}
private static Vehicle createFuelVehicle(eVehicleType i_VehicleType)
{
Vehicle createdVehicle = null;
FuelEngine createdFuelEngine = null;
switch (i_VehicleType)
{
case eVehicleType.Car:
createdFuelEngine = new FuelEngine(0, 60, FuelEngine.eFuelType.Octan96);
createdVehicle = createCar(createdFuelEngine);
break;
case eVehicleType.Motorbike:
createdFuelEngine = new FuelEngine(0, 7, FuelEngine.eFuelType.Octan95);
createdVehicle = createMotorbike(createdFuelEngine);
break;
case eVehicleType.Truck:
createdFuelEngine = new FuelEngine(0, 120, FuelEngine.eFuelType.Soler);
createdVehicle = createTruck(createdFuelEngine);
break;
}
return(createdVehicle);
}
public Car(
eVehicle i_TypeOfVehicle,
string i_ModelName,
string i_LicenseNumber,
string i_OwnerPhoneNumber,
string i_OwnerName,
string i_WheelManufacturer,
float i_CurrentAirPressure,
float i_CurrentCapacity)
: base(
i_TypeOfVehicle,
i_ModelName,
i_LicenseNumber,
i_OwnerPhoneNumber,
i_OwnerName,
i_WheelManufacturer,
i_CurrentAirPressure,
i_CurrentCapacity)
{
AddWheels(i_CurrentAirPressure, 4, 32);
if (i_TypeOfVehicle == eVehicle.ElectricCar)
{
CurrEngine = new ElectricEngine(2.1f);
CurrEngine.CurrentCapacity = i_CurrentCapacity;
}
else
{
CurrEngine = new FuelEngine(60, eFuelType.Octane96);
CurrEngine.CurrentCapacity = i_CurrentCapacity;
}
}
protected virtual StringBuilder ShowInfoVehicle()
{
StringBuilder vehicleInfo = new StringBuilder();
vehicleInfo.AppendLine("ModelName: " + m_ModelName);
vehicleInfo.AppendLine("License Number: " + r_LicenseNumber);
vehicleInfo.AppendLine("Wheels manufacturer: " + m_Wheels[1].ManufacturerName);
vehicleInfo.AppendLine("Wheels current air: " + m_Wheels[1].CurrentAirPressure.ToString());
vehicleInfo.AppendLine("Wheels max air pressure: " + m_Wheels[1].MaximumAirPressure.ToString());
if (r_Engine is FuelEngine)
{
FuelEngine fuelEngine = r_Engine as FuelEngine;
vehicleInfo.AppendLine("Engine type: " + Enum.GetName(typeof(Engine.eEngineType), fuelEngine.EngineType));
vehicleInfo.AppendLine("Fuel type: " + Enum.GetName(typeof(FuelEngine.eFuelType), fuelEngine.FuelType));
vehicleInfo.AppendLine("Remaining fuel amount: " + fuelEngine.Remaining.ToString());
vehicleInfo.AppendLine("Maximum fuel amount: " + fuelEngine.MaximumCapacity.ToString());
}
else
{
vehicleInfo.AppendLine("Engine type: " + Enum.GetName(typeof(Engine.eEngineType), r_Engine.EngineType));
vehicleInfo.AppendLine("Remaining battery energy hours : " + r_Engine.Remaining.ToString());
vehicleInfo.AppendLine("Maximum battery energy in hours : " + r_Engine.MaximumCapacity.ToString());
}
return(vehicleInfo);
}
public bool FuelingVehicle(string i_LicenseNumber, eFuel i_Fual, int i_AmountToFaul)
{
if (!VehicleInGarage(i_LicenseNumber))
{
throw new ArgumentNullException("This Vehicle doesn't exist in the garage \n");
}
UserDetails currentUserDetails = m_GarageList[i_LicenseNumber];
Vehicle vehicleToFaul = currentUserDetails.Vehicle;
Engine engineToFaul = vehicleToFaul.VehicleEngine;
FuelEngine fuelEngine = engineToFaul as FuelEngine;
if (fuelEngine == null)
{
throw new ArgumentException("This is not fuel car \n");
}
eFuel correctFuel = fuelEngine.FuelType;
if (!correctFuel.Equals(i_Fual))
{
throw new ArgumentException("You entered wrong fuel type");
}
bool tryToFuel = fuelEngine.Fill(i_AmountToFaul, i_Fual);
return(tryToFuel);
}
private static Truck CreateTruck(bool i_Toxic, float i_MaxWeight, string i_Model, string i_LicenseNumber,
float i_EnergyLevel, string i_Manufacturer, float i_AirPreasure)
{
List <Wheel> wheels = Car.CreateCarWheels(i_Manufacturer, i_AirPreasure);
FuelEngine truckEngine = CreateFuelEngine(k_TruckCycleFuelCapacity, i_EnergyLevel, eFuelType.Octan96);
return(new Truck(i_Toxic, truckEngine, i_MaxWeight, i_Model, i_LicenseNumber, wheels));
}
internal FuelBasedTruck(string i_ModelName, string i_LicenseNumber, string i_OwnerName, string i_OwnerPhoneNumber) : base(i_ModelName, i_LicenseNumber, i_OwnerName, i_OwnerPhoneNumber)
{
FuelBasedTruckEngine = new FuelEngine();
FuelBasedTruckEngine.TypeOfFuel = m_TypeOfFuel;
FuelBasedTruckEngine.MaxAmountOfFuel = c_MaxAmountOfFuel;
EnergyType = FuelBasedTruckEngine;
IsCooled = AggregateEnumTypes.eIsCooled.No;
VolumeOfCargo = 0;
}
public void RefuelVehicle(string i_LicenseNumber, string i_FuelType, string i_Amount)
{
Vehicle vehicle;
vehicle = m_VehicleDetailsList[i_LicenseNumber].Vehicle;
FuelEngine engine = vehicle.VehicleEngine as FuelEngine;
engine.Refuel(float.Parse(i_Amount), (FuelEngine.eFuelType) int.Parse(i_FuelType));
}
internal FuelBasedMotorcycle(string i_ModelName, string i_LicenseNumber, string i_OwnerName, string i_OwnerPhoneNumber)
: base(i_ModelName, i_LicenseNumber, i_OwnerName, i_OwnerPhoneNumber)
{
FuelBasedMotorcycleEngine = new FuelEngine();
FuelBasedMotorcycleEngine.TypeOfFuel = m_TypeOfFuel;
FuelBasedMotorcycleEngine.MaxAmountOfFuel = c_MaxAmountOfFuel;
EnergyType = FuelBasedMotorcycleEngine;
TypeOfLicenses = AggregateEnumTypes.eTypeOfLicences.A;
EngineVolume = 0;
}
internal FuelBasedCar(string i_ModelName, string i_LicenseNumber, string i_OwnerName, string i_OwnerPhoneNumber)
: base(i_ModelName, i_LicenseNumber, i_OwnerName, i_OwnerPhoneNumber)
{
FuelBasedCarEngine = new FuelEngine();
FuelBasedCarEngine.TypeOfFuel = m_TypeOfFuel;
FuelBasedCarEngine.MaxAmountOfFuel = c_MaxAmountOfFuel;
EnergyType = FuelBasedCarEngine;
TypeOfColor = AggregateEnumTypes.eTypeColor.Black;
NumOfDoors = AggregateEnumTypes.eNumOfDoors.Two;
}
internal Truck(string i_LicenseNumber, eVehicleType i_VehicleType)
: base(i_LicenseNumber, k_MaxWheelAirPressure, k_NumOfWheels, FuelEngine.eFuelType.Soler)
{
if (i_VehicleType == eVehicleType.FuelTruck)
{
EngineSystem = new FuelEngine(k_MaxFuelAmount, FuelEngine.eFuelType.Soler);
}
VehicleType = i_VehicleType;
}
internal Car(eVehicleType i_VehicleType, string i_plateNumber) : base(4, 32, i_VehicleType, i_plateNumber)
{
if (i_VehicleType.Equals(eVehicleType.ElectricCar))
{
m_Engine = new ElectricEngine(2.1f);
}
else
{
m_Engine = new FuelEngine(60f, eFuelType.Octan96);
}
}
public void FillFuel(string i_LicenseId, float i_AmountOfFuel, VehiclesEnums.eFuelType i_TypeOfFuel)
{
FuelEngine eng = m_Vehicles[i_LicenseId].Vehicle.Engine as FuelEngine;
if (eng == null)
{
throw new ArgumentException(string.Format(k_NotFuelVehicle, i_LicenseId, Environment.NewLine));
}
eng.FillFuel(i_AmountOfFuel, i_TypeOfFuel);
}
internal Motorbike(eVehicleType i_VehicleType, string i_plateNumber) : base(2, 30, i_VehicleType, i_plateNumber)
{
if (i_VehicleType.Equals(eVehicleType.ElectricMotorbike))
{
m_Engine = new ElectricEngine(1.2f);
}
else
{
m_Engine = new FuelEngine(7f, eFuelType.Octan95);
}
}
public void FuelUpVehicle(string i_LicenseNumber, float fuelAmmountToAdd, string fuelType)
{
if (m_VechicleRecords[i_LicenseNumber].Vehicle.Engine is FuelEngine)
{
FuelEngine fuelEngine = m_VechicleRecords[i_LicenseNumber].Vehicle.Engine as FuelEngine;
eFuelType fuelTypeParsedToEnum = (eFuelType)Enum.Parse(typeof(eFuelType), fuelType);
fuelEngine.FillFuel(fuelAmmountToAdd, fuelTypeParsedToEnum);
}
else
{
throw new ArgumentException("Trying to fuel up vehicle with electric engine ");
}
}
// resposible to validate data and fill up gas
public void FillUpGas(string i_LicenseNumber, FuelEngine.eFuelType i_FuelType, float i_AmountToFill)
{
Customer currentCar = m_Customers[i_LicenseNumber];
if (currentCar.CustomerVehicle.VehicleEngine.TypeOfEngine != "Fuel")
{
throw new Exception("this Vehicle is an electric Vehicle");
}
FuelEngine engineToFill = (FuelEngine)currentCar.CustomerVehicle.VehicleEngine;
engineToFill.FillFuel(i_AmountToFill, i_FuelType);
}
internal MotorCycle(string i_LicenseNumber, eVehicleType i_VehicleType)
: base(i_LicenseNumber, m_MaxWheelAirPressure, m_NumOfWheels, FuelEngine.eFuelType.Octan95)
{
if (i_VehicleType == eVehicleType.FuelMotorCycle)
{
EngineSystem = new FuelEngine(k_MaxFuelAmount, FuelEngine.eFuelType.Octan95);
}
else
{
EngineSystem = new ElectricEngine(k_MaxBatteryTime);
}
VehicleType = eVehicleType.FuelMotorCycle;
}
public Car CreateNewFuelCar(Dictionary <string, string> i_VehicleDictionary)
{
i_VehicleDictionary.Add("Number of wheels:", "4");
i_VehicleDictionary.Add("Wheel maximal air pressure:", "31");
i_VehicleDictionary.Add("Fuel type:", "Octan96");
i_VehicleDictionary.Add("max fuel amount:", "55");
validationOfFuelEngine(i_VehicleDictionary);
validationOfCar(i_VehicleDictionary);
validationOfWheels(i_VehicleDictionary);
FuelEngine fuelEngine = new FuelEngine(i_VehicleDictionary);
Car fueledCar = new Car(i_VehicleDictionary, fuelEngine);
return(fueledCar);
}
//we get here a completed vehicle dictionary after asking the client all relevant questions regarding his vehicle
//add constant values to each vehicle data
//and validate all the values before sending them to the constructor
public Motorcycle CreateNewFuelMotorcycle(Dictionary <string, string> i_VehicleDictionary)
{
i_VehicleDictionary.Add("Number of wheels:", "2");
i_VehicleDictionary.Add("Wheel maximal air pressure:", "33");
i_VehicleDictionary.Add("Fuel type:", "Octan95");
i_VehicleDictionary.Add("max fuel amount:", "8");
validationOfFuelEngine(i_VehicleDictionary);
validationOfMotorcycle(i_VehicleDictionary);
validationOfWheels(i_VehicleDictionary);
FuelEngine fuelEngine = new FuelEngine(i_VehicleDictionary);
Motorcycle fueledMotorcycle = new Motorcycle(i_VehicleDictionary, fuelEngine);
return(fueledMotorcycle);
}
internal Car(string i_LicenseNumber, eVehicleType i_VehicleType)
: base(i_LicenseNumber, k_MaxWheelAirPressure, k_NumOfWheels, FuelEngine.eFuelType.Octan98)
{
if (i_VehicleType == eVehicleType.FuelCar)
{
EngineSystem = new FuelEngine(k_MaxFuelAmount, FuelEngine.eFuelType.Octan98);
}
else
{
EngineSystem = new ElectricEngine(k_MaxBatteryTime);
}
VehicleType = i_VehicleType;
}
public Truck CreateNewTruck(Dictionary <string, string> i_VehicleDictionary)
{
i_VehicleDictionary.Add("Number of wheels:", "12");
i_VehicleDictionary.Add("Wheel maximal air pressure:", "26");
i_VehicleDictionary.Add("Fuel type:", "Soler");
i_VehicleDictionary.Add("max fuel amount:", "110");
validationOfFuelEngine(i_VehicleDictionary);
validationOfTruck(i_VehicleDictionary);
validationOfWheels(i_VehicleDictionary);
FuelEngine fuelEngine = new FuelEngine(i_VehicleDictionary);
Truck fueledTruck = new Truck(i_VehicleDictionary, fuelEngine);
return(fueledTruck);
}
private static IEngine InitializeEngine(DataBase i_UserInput)
{
IEngine engine;
if (i_UserInput.m_IsElectric)
{
engine = new ElectricEngine(i_UserInput.m_BatteryTimeLeft, i_UserInput.m_MaxBatteryLife);
}
else
{
engine = new FuelEngine(i_UserInput.m_FuelType, i_UserInput.m_AmountOfFuel, i_UserInput.m_MaxFuelAmount);
}
return(engine);
}
public void FuelVehicle(string i_LicensePlateNumber, float i_FillFuelQuantity, FuelEngine.eFuelType i_FuelType)
{
FuelEngine FuelEngine = r_Vehicles[i_LicensePlateNumber].Engine as FuelEngine;
if (FuelEngine != null)
{
FuelEngine.VehicleFueling(i_FuelType, i_FillFuelQuantity);
}
else
{
throw new ArgumentException("Incorrect engine");
}
r_Vehicles[i_LicensePlateNumber].UpdateVehicleEngineEnergyPrecentage();
}
public static void AddFuel(string i_LicenceNumber, float i_EnergyToAdd, int i_FuelType, Vehicle i_Vehicle)
{
Engine vehicleEngineType = i_Vehicle.Engine;
FuelEngine fuelEngine = vehicleEngineType as FuelEngine;
eFuelType fuelType = (eFuelType)i_FuelType;
if (fuelEngine.FuelType != fuelType)
{
throw new ArgumentException(string.Format("Invalid Fuel Type! This vehicle runs on {0}", fuelEngine.FuelType));
}
else
{
(vehicleEngineType as FuelEngine).AddEnergyToVehicle(i_EnergyToAdd);
}
}
