private static Vehicle createBike(Engine.eEngineType i_Engine, List <string> i_VehicleParametersStrings, eVehicleType i_VehicleType)
{
string modelName;
string licenseNumber;
float energyPercentageLeft;
string tireManufactureName;
float tireCurrentAirPressure;
Bike.eLicenseType licenseType = (Bike.eLicenseType)Enum.Parse(typeof(Bike.eLicenseType), i_VehicleParametersStrings[(int)eExtraParametersInputOrder.BikeLicenseType]);
getVehicleParameters(
i_VehicleParametersStrings,
out modelName,
out licenseNumber,
out energyPercentageLeft,
out tireManufactureName,
out tireCurrentAirPressure);
Engine engine = i_Engine == Engine.eEngineType.FuelEngine
? createFuelEngine(Bike.k_FuelType, Bike.k_MaxTankCapacity)
: (Engine)createElectricEngine(Bike.k_MaxBatteryTime);
Bike bike = new Bike(i_VehicleType, modelName, licenseNumber, new Tire[Bike.k_NumberOfTires], engine, energyPercentageLeft, tireManufactureName, tireCurrentAirPressure, licenseType, Bike.k_MaxTankCapacity);
return(bike);
}
//-----------------------------------------------------------------//
public void FillEngineUp(string i_LicensePlate, float i_HowMuchToIncrease, Engine.eEngineType i_EngineType, Engine.FuelEngine.eFuelType i_FuelType)
{
try
{
InformationOfVehicle vehicleToFuel = this.CheckForLicensePlate(i_LicensePlate);
if ((vehicleToFuel != null) && (vehicleToFuel.Vehicle.Engine is Engine.FuelEngine) && (i_EngineType == Engine.eEngineType.Fuel))
{
(vehicleToFuel.Vehicle.Engine as Engine.FuelEngine).Refuel(i_HowMuchToIncrease, i_FuelType);
}
else if ((vehicleToFuel != null) && (vehicleToFuel.Vehicle.Engine is Engine.ElectricEngine) && (i_EngineType == Engine.eEngineType.Electric))
{
(vehicleToFuel.Vehicle.Engine as Engine.ElectricEngine).ChargeBattery(i_HowMuchToIncrease);
}
else
{
if (i_EngineType == Engine.eEngineType.Fuel)
{
throw new ArgumentException("This Vehicle cannot be fueled" + Environment.NewLine);
}
else
{
throw new ArgumentException("This Vehicle cannot be charged" + Environment.NewLine);
}
}
}
catch (ArgumentException exception)
{
throw exception;
}
catch (ValueOutOfRangeException exeption)
{
throw exeption;
}
}
private static Vehicle createCar(Engine.eEngineType i_Engine, List <string> i_VehicleParametersStrings, eVehicleType i_VehicleType)
{
string modelName;
string licenseNumber;
float energyPercentageLeft;
string tireManufactureName;
float tireCurrentAirPressure;
Car.eCarColors carColor = (Car.eCarColors)Enum.Parse(typeof(Car.eCarColors), i_VehicleParametersStrings[(int)eExtraParametersInputOrder.CarColor]);
Car.eNumberOfDoors numberOfDoors = (Car.eNumberOfDoors)Enum.Parse(typeof(Car.eNumberOfDoors), i_VehicleParametersStrings[(int)eExtraParametersInputOrder.CarNumOfDoors]);
getVehicleParameters(
i_VehicleParametersStrings,
out modelName,
out licenseNumber,
out energyPercentageLeft,
out tireManufactureName,
out tireCurrentAirPressure);
Engine engine = i_Engine == Engine.eEngineType.FuelEngine
? (Engine)createFuelEngine(Car.k_FuelType, Car.k_MaxTankCapacity)
: createElectricEngine(Car.k_MaxBatteryTime);
Car car = new Car(i_VehicleType, modelName, licenseNumber, new Tire[Car.k_NumberOfTires], engine, energyPercentageLeft, tireManufactureName, tireCurrentAirPressure, carColor, numberOfDoors);
return(car);
}
internal Truck(string io_ModelName,
string io_LicenseNumber, List <Wheel> io_Wheels,
Engine.eEngineType io_EngineType, float io_EenergyLeft,
List <object> io_UniqueParametersList) : base(io_ModelName, io_LicenseNumber, io_Wheels, io_EngineType, io_EenergyLeft, eVehicleType.Car)
{
if (io_EngineType == Engine.eEngineType.Electric)
{
throw new ArgumentException();
}
try
{
m_IsToxic = (bool)io_UniqueParametersList[0];
m_MaxWeight = float.Parse((string)io_UniqueParametersList[1]);
if (m_MaxWeight <= 0)
{
throw new ValueOutOfRangeException(1, int.MaxValue);
}
}
catch (FormatException exception)
{
throw exception;
}
}
private void initializeEngine(Engine.eEngineType i_EngineType, float i_CurrentEnergyAmount)
{
if (i_EngineType == Engine.eEngineType.Fuel)
{
this.m_Engine = new FuelEngine(FuelEngine.eFuelTankCapacity.Motorcycle, i_CurrentEnergyAmount, FuelEngine.eFuelType.Octan95);
}
else
{
this.m_Engine = new ElectricEngine(ElectricEngine.eFullChargeMinutesCapacity.Motorcycle, i_CurrentEnergyAmount);
}
}
protected Vehicle(string i_LicenseNumber, Engine.eEngineType i_EngineType, float i_MaxEngineEnergyCapacity)
{
r_LicenseNumber = i_LicenseNumber;
switch (i_EngineType)
{
case Engine.eEngineType.Electric:
m_Engine = new ElectricEngine(i_MaxEngineEnergyCapacity);
break;
case Engine.eEngineType.Gas:
m_Engine = new GasEngine(i_MaxEngineEnergyCapacity);
break;
}
}
private static Truck makeTruck(string io_ModelName,
string io_LicenseNumber, List <Wheel> io_Wheels,
Engine.eEngineType io_EngineType, float ioEenergyLeft,
List <object> io_UniqueParametersList)
{
try
{
return(new Truck(io_ModelName,
io_LicenseNumber, io_Wheels,
io_EngineType, ioEenergyLeft,
io_UniqueParametersList));
}
catch (Exception exception)
{
throw exception;
}
}
private static float getAmountOfEnergyForAddition(Engine.eEngineType i_EngineType)
{
string energyAdditionMsgFormat = string.Format("Please enter the amount of {0} that you would like to add: ", i_EngineType == Engine.eEngineType.Fuel ? "fuel" : "minutes");
Console.WriteLine(energyAdditionMsgFormat);
string energyAdditionInput = Console.ReadLine();
while (!checkPositiveFloatValueValidation(energyAdditionInput))
{
Console.WriteLine("Invalid input, please enter a positive number");
energyAdditionInput = Console.ReadLine();
}
float energyAddition = float.Parse(energyAdditionInput);
return(energyAddition);
}
private static Engine createEngine(
Engine.eEngineType i_EngineType,
float i_MaxCapacity,
GasEngine.eGasType?i_GasType = null)
{
Engine engine = null;
if (i_EngineType == Engine.eEngineType.Electric)
{
engine = new ElectricEngine(i_MaxCapacity);
}
else
{
engine = new GasEngine(i_MaxCapacity, (GasEngine.eGasType)i_GasType);
}
return(engine);
}
public void AddClient(string io_ClientName, string io_lientPhoneNumber, string io_ModelName,
string io_LicenseNumber, Vehicle.eVehicleType io_VehicleType, string io_WheelsManufacture, float io_WheelsAirPressure,
Engine.eEngineType io_EngineType, float io_EenergyLeft,
List <object> io_UniqueParametersList)
{
try
{
List <Wheel> wheels = setAllWheels(io_WheelsManufacture, io_WheelsAirPressure, io_VehicleType);
Client newClient = new Client(io_ClientName, io_lientPhoneNumber, io_ModelName, io_LicenseNumber,
io_VehicleType, wheels, io_EngineType, io_EenergyLeft, io_UniqueParametersList);
m_Clients.Add(io_LicenseNumber, newClient);
}
catch (Exception e)
{
throw e;
}
}
private void fillEnergySource(bool i_FuelRequest)
{
string requestedCarLicenseNumber =
this.getRegularParameterDetails(k_LicenseNumber, ParameterChecker.eExpectedInputType.All);
if (this.m_Garage.CheckIfVehicleInGarageByLicenseNumber(requestedCarLicenseNumber))
{
const string k_FuelString = "Please enter how much fuel (in liters) you want to add.";
const string k_BatteryString = "Please enter how much battery time (in hours) you want to add.";
Engine.eEngineType engineType = this.m_Garage.VehiclesDictionary[requestedCarLicenseNumber].Vehicle
.Engine.EngineType;
bool isFuelEngine = engineType == Engine.eEngineType.FuelEngine;
if (isFuelEngine != i_FuelRequest)
{
throw new ArgumentException($"Wrong request to fill the {engineType}.");
}
Console.WriteLine(isFuelEngine ? k_FuelString : k_BatteryString);
if (float.TryParse(Console.ReadLine(), out float energySourceAmountToAdd))
{
if (engineType == Engine.eEngineType.FuelEngine)
{
FuelEngine.eFuelType fuelType = this.getFuelType();
this.m_Garage.HandleEnergySourceFilling(
requestedCarLicenseNumber,
energySourceAmountToAdd,
fuelType);
}
else
{
this.m_Garage.HandleEnergySourceFilling(requestedCarLicenseNumber, energySourceAmountToAdd);
}
Console.WriteLine(
energySourceAmountToAdd + (engineType == Engine.eEngineType.FuelEngine
? " liters were added."
: " hours were charged."));
}
}
else
{
throw new ArgumentException(k_InvalidLicenseNumberExceptionString);
}
}
internal static Vehicle MakeVehicle(string io_ModelName,
string io_LicenseNumber, Vehicle.eVehicleType io_VehicleType, List <Wheel> io_Wheels,
Engine.eEngineType io_EngineType, float ioEenergyLeft,
List <object> io_UniqueParametersList)
{
Vehicle newVehicle;
try
{
switch (io_VehicleType)
{
case Vehicle.eVehicleType.Car:
newVehicle = makeCar(io_ModelName,
io_LicenseNumber, io_Wheels,
io_EngineType, ioEenergyLeft,
io_UniqueParametersList);
break;
case Vehicle.eVehicleType.Motorcycle:
newVehicle = makeMotorcycle(io_ModelName,
io_LicenseNumber, io_Wheels,
io_EngineType, ioEenergyLeft,
io_UniqueParametersList);
break;
case Vehicle.eVehicleType.Truck:
newVehicle = makeTruck(io_ModelName,
io_LicenseNumber, io_Wheels,
io_EngineType, ioEenergyLeft,
io_UniqueParametersList);
break;
default:
throw new ArgumentException();
}
return(newVehicle);
}
catch (Exception exception)
{
throw exception;
}
}
internal Motorcycle(string io_ModelName,
string io_LicenseNumber, List <Wheel> io_Wheels,
Engine.eEngineType io_EngineType, float io_EenergyLeft,
List <object> io_UniqueParametersList) : base(io_ModelName, io_LicenseNumber, io_Wheels, io_EngineType, io_EenergyLeft, eVehicleType.Car)
{
try
{
m_LicenseType = (eLicenseType)io_UniqueParametersList[0];
m_MotorVolume = int.Parse((string)io_UniqueParametersList[1]);
if (m_MotorVolume < 1)
{
throw new ValueOutOfRangeException(1, Int32.MaxValue);
}
}
catch (FormatException exception)
{
throw exception;
}
}
private void printEnergyLoadingMessage(Engine.eEngineType i_EngineType, float i_PreviousEnergyAmount, float i_NewEnergyAmount)
{
string fuelTankMsg = string.Format(
@"Current {0} amount in percentage: {1}%
LOADING........... ",
i_EngineType == Engine.eEngineType.Fuel ? "fuel" : "electricity",
i_PreviousEnergyAmount);
Console.WriteLine(fuelTankMsg);
System.Threading.Thread.Sleep(2000);
fuelTankMsg = string.Format(
@"Current {0} amount in percentage after refueling: {1}%
",
i_EngineType == Engine.eEngineType.Fuel ? "fuel" : "electricity",
i_NewEnergyAmount);
Console.WriteLine(fuelTankMsg);
System.Threading.Thread.Sleep(1000);
}
internal Car(string io_ModelName,
string io_LicenseNumber, List <Wheel> io_Wheels,
Engine.eEngineType io_EngineType, float io_EenergyLeft,
List <object> io_UniqueParametersList) : base(io_ModelName, io_LicenseNumber, io_Wheels, io_EngineType, io_EenergyLeft, eVehicleType.Car)
{
try
{
m_CarColor = (eCarColor)io_UniqueParametersList[0];
m_DoorsAmount = int.Parse((string)io_UniqueParametersList[1]);
if (m_DoorsAmount < 2 || m_DoorsAmount > 5)
{
throw new ValueOutOfRangeException(2, 5);
}
}
catch (FormatException exception)
{
throw exception;
}
}
public Car(Engine.eEngineType i_EngineType)
: base()
{
switch (i_EngineType)
{
case Engine.eEngineType.Fuel:
this.EngineOfVehicle = new FuelEngine(k_CarFuelType);
this.EngineOfVehicle.MaxEnergy = 45;
break;
case Engine.eEngineType.Electric:
this.EngineOfVehicle = new ElectricEngine();
this.EngineOfVehicle.MaxEnergy = 3.2f;
break;
}
for (int i = 0; i < k_NumberOfWheels; i++)
{
this.ListOfWheels.Add(new Wheel(k_MaxWheelPressure));
}
}
public MotorCycle(Engine.eEngineType i_EngineType)
: base()
{
switch (i_EngineType)
{
case Engine.eEngineType.Fuel:
this.EngineOfVehicle = new FuelEngine(FuelEngine.eFuelType.Octan96);
this.EngineOfVehicle.MaxEnergy = 6;
break;
case Engine.eEngineType.Electric:
this.EngineOfVehicle = new ElectricEngine();
this.EngineOfVehicle.MaxEnergy = 1.8f;
break;
}
for (int i = 0; i < k_NumberOfWheels; i++)
{
this.ListOfWheels.Add(new Wheel(k_MaxWheelPressure));
}
}
internal Client(string i_ClientName, string i_ClientPhoneNumber, string io_ModelName,
string io_LicenseNumber, Vehicle.eVehicleType io_VehicleType, List <Wheel> io_Wheels,
Engine.eEngineType io_EngineType, float ioEenergyLeft,
List <object> io_UniqueParametersList)
{
try
{
// set local fields
m_Name = i_ClientName;
m_PhoneNumber = i_ClientPhoneNumber;
m_VehicleType = io_VehicleType;
m_Vehicle = Factory.MakeVehicle(io_ModelName,
io_LicenseNumber, io_VehicleType, io_Wheels,
io_EngineType, ioEenergyLeft,
io_UniqueParametersList);
}
catch (FormatException e)
{
throw e;
}
}
//-----------------------------------------------------------------//
private void powerUpVehicle(Garage i_Garage, Engine.eEngineType i_EngineType)
{
int userMenuChoice = 1, userFuelTypeChoice = 0;
float howMuchToAdd;
while (userMenuChoice == 1)
{
try
{
string licenseNumber = this.getLicenseNumberFromUser();
this.getFuelTypeFromUserAndHowMuchToAdd(out userFuelTypeChoice, out howMuchToAdd, i_EngineType);
i_Garage.FillEngineUp(licenseNumber, howMuchToAdd, i_EngineType, (Engine.FuelEngine.eFuelType)userFuelTypeChoice);
userMenuChoice = 2;
Console.WriteLine("Engine of vehicle succesfully filled up");
this.printBackToMenuPause();
break;
}
catch (FormatException exception)
{
Console.WriteLine(exception.Message);
}
catch (ValueOutOfRangeException exception)
{
Console.WriteLine(exception.Message);
if (exception.MinValue != exception.MaxValue)
{
Console.WriteLine("Value ranges are {0} to {1}", exception.MinValue, exception.MaxValue);
}
}
catch (ArgumentException exception)
{
Console.WriteLine(exception.Message);
}
userMenuChoice = this.printWrongInputMenuGetUserInput();
}
}
//-----------------------------------------------------------------//
private void getFuelTypeFromUserAndHowMuchToAdd(out int o_UserChoiceFuel, out float o_HowMuchToAdd, Engine.eEngineType i_EngineType)
{
o_UserChoiceFuel = 0;
if (i_EngineType == Engine.eEngineType.Fuel)
{
Console.WriteLine("Please enter the type of fuel you want to add");
this.printFuelMenu();
o_UserChoiceFuel = (int)this.getValidInputValueInRange(1, 4);
}
Console.Write("Please enter the amount you want to power the engine: ");
o_HowMuchToAdd = this.getValidInputValueInRange(0, 120);
}
// C'tor
public Truck(string i_LicenseNumber, string i_ModelName, float i_EnergyPercentageLeft, Engine.eEngineType i_EngineType)
: base(i_LicenseNumber, i_ModelName)
{
InitializeEngine(i_EngineType, i_EnergyPercentageLeft);
}
internal void InitializeEngine(Engine.eEngineType i_EngineType, float i_CurrentEnergyAmount)
{
this.m_Engine = new FuelEngine(FuelEngine.eFuelTankCapacity.Truck, i_CurrentEnergyAmount, FuelEngine.eFuelType.Soler);
}
// Adds a vehicle to the garage, if vehicle is already in the garage, sets status as maintenence
internal void AddVehicle(GarageLogic.Garage i_Garage)
{
string vehicle = string.Empty;
Dictionary <string, string> parametrs = new Dictionary <string, string>();
string licenseNumber = string.Empty;
string typeOfWheels = string.Empty;
string modelType = string.Empty;
bool validationFlag = false;
string name = string.Empty;
string phoneNumber = string.Empty;
Console.Clear();
// Gets license number, if already exists change status to maintenence
Console.WriteLine("Enter License Number");
licenseNumber = Console.ReadLine();
try
{
i_Garage.IsNotInGarage(licenseNumber);
}
catch
{
i_Garage.ChangeCarStatus(licenseNumber, Garage.eCarStatus.Maintenence);
Console.WriteLine("Vehicle already in garage, status changes to maintenence");
Thread.Sleep(1200);
return;
}
Console.Clear();
// get customer inforamtion
Console.WriteLine("Please write your name");
name = Console.ReadLine();
Console.WriteLine("Please write your phone number");
phoneNumber = Console.ReadLine();
Console.Clear();
// get and validate vehicle type
System.Console.WriteLine("Please enter your vehicle type, those are the vehicle we support:");
int i = 0;
foreach (VehicleCreation.eVehicleType typeOfCar in Enum.GetValues(typeof(VehicleCreation.eVehicleType)))
{
System.Console.WriteLine("* For " + typeOfCar.ToString() + " Press " + i);
i++;
}
while (!validationFlag)
{
try
{
vehicle = System.Console.ReadLine();
validationFlag = Validation.TypeOfVehicle(vehicle);
}
catch (Exception e)
{
validationFlag = false;
System.Console.WriteLine(e.Message);
}
}
parametrs.Add("Licence Number", licenseNumber);
parametrs.Add("Vehicle Type", vehicle.ToString());
Enum.TryParse <VehicleCreation.eVehicleType>(vehicle, out VehicleCreation.eVehicleType vehicleType);
// get Vehicle Model
Console.WriteLine("Please enter vehicle model");
modelType = Console.ReadLine();
parametrs.Add("Model Type", modelType);
Console.Clear();
// get wheels information
System.Console.WriteLine("please enter the type of your wheels");
typeOfWheels = Console.ReadLine();
parametrs.Add("Type Of Wheel", typeOfWheels);
string maxAirPressure = string.Empty;
System.Console.WriteLine("Please enter the max air of your wheels");
bool isNumber = false;
while (!isNumber)
{
maxAirPressure = Console.ReadLine();
try
{
ValidtysUI.CheckIfANumber(maxAirPressure);
isNumber = true;
}
catch (FormatException e)
{
Console.WriteLine(e.Message);
}
}
isNumber = false;
parametrs.Add("Maximal Air Pressure", maxAirPressure);
string currentAirPressure = string.Empty;
System.Console.WriteLine("Please enter the current air of your wheels");
bool isVaildAir = false;
while (!isVaildAir)
{
currentAirPressure = Console.ReadLine();
try
{
ValidtysUI.CheckInputValidity(currentAirPressure, maxAirPressure);
isVaildAir = true;
}
catch (ArgumentException e)
{
Console.WriteLine(e.Message);
}
catch (FormatException e)
{
Console.WriteLine(e.Message);
}
}
parametrs.Add("Current Wheel Pressure", currentAirPressure);
Console.Clear();
// get engine information
string maximumEnergy = string.Empty;
bool isValid = false;
Console.WriteLine("Please enter the maximun energy of your vehicle");
while (!isNumber)
{
maximumEnergy = Console.ReadLine();
try
{
ValidtysUI.CheckIfANumber(maximumEnergy);
isNumber = true;
}
catch (FormatException e)
{
Console.WriteLine(e.Message);
}
}
parametrs.Add("Max energy", maximumEnergy);
string energyLeft = string.Empty;
Console.WriteLine("Please enter the enregy left in the vehicle");
while (!isValid)
{
energyLeft = Console.ReadLine();
try
{
ValidtysUI.CheckInputValidity(energyLeft, maximumEnergy);
isValid = true;
}
catch (ArgumentException e)
{
Console.WriteLine(e.Message);
}
catch (FormatException e)
{
Console.WriteLine(e.Message);
}
}
parametrs.Add("Amount Of Energy Left", energyLeft);
Console.WriteLine("Is the vehicle electric?");
Console.WriteLine("1. yes");
Console.WriteLine("2. no");
string answer = Console.ReadLine();
Engine.eEngineType type = Engine.eEngineType.Electric;
bool isOneOrTwo = false;
while (!isOneOrTwo)
{
if (answer == "1")
{
type = Engine.eEngineType.Electric;
isOneOrTwo = true;
}
if (answer == "2")
{
type = Engine.eEngineType.Fuel;
int numberOfChoice = 1;
Console.WriteLine("Please pick one of the Fuel types below: ");
// iterate through gas types available and prints them
foreach (GarageLogic.FuelEngine.eFuelType fuelType in Enum.GetValues(typeof(GarageLogic.FuelEngine.eFuelType)))
{
Console.WriteLine(numberOfChoice + ". " + fuelType.ToString());
numberOfChoice++;
}
bool isFuelType = false;
string chosenFuelType = string.Empty;
while (!isFuelType)
{
chosenFuelType = Console.ReadLine();
try
{
ValidtysUI.CheckFuelType(chosenFuelType);
Array enumValues = Enum.GetValues(typeof(FuelEngine.eFuelType));
int chosenAsInt = int.Parse(chosenFuelType) - 1;
parametrs.Add("Fuel Kind", enumValues.GetValue(chosenAsInt).ToString());
isFuelType = true;
}
catch (ArgumentException e)
{
Console.WriteLine(e.Message);
}
catch (FormatException e)
{
Console.WriteLine(e.Message);
}
}
isOneOrTwo = true;
}
if (answer != "1" && answer != "2")
{
Console.WriteLine("please enter 1 or 2");
answer = Console.ReadLine();
}
}
parametrs.Add("Engine Type", type.ToString());
Console.Clear();
ExpendVehicleParameter(vehicleType, parametrs);
VehicleCreation BuildVehicle = new VehicleCreation(parametrs, vehicleType);
Vehicle newVehicle = BuildVehicle.Vehicle;
i_Garage.AddCustomer(name, phoneNumber, newVehicle);
// show success message and takes back to main menu
SuccessFinishOperation();
}
internal Vehicle(string i_ModelName, string i_LicenseNumber, List <Wheel> i_Wheels, Engine.eEngineType io_EngineType,
float io_EnergyLeft, eVehicleType io_VehicleType)
{
try
{
m_ModelName = i_ModelName;
m_LicenseNumber = i_LicenseNumber;
m_Wheels = i_Wheels;
m_RepairStatus = eRepairStatus.InProgress;
m_Engine = new Engine(io_EngineType, io_EnergyLeft, io_VehicleType);
}
catch (FormatException exception)
{
throw exception;
}
}
public Motorcycle(string i_LicenseNumber, Engine.eEngineType i_EngineType, float i_MaxEngineEnergyCapacity)
: base(i_LicenseNumber, i_EngineType, i_MaxEngineEnergyCapacity)
{
}
