// Helper for printing vehicle list.
private static void PrintVehicleList(GarageManager i_GarageManager)
{
Console.WriteLine("choose what vehicle list you wish to print:\n" +
"(1) In repair\t(2) Repaired\t(3) Payed\t(4) All-not filterd");
string inputListStr = Console.ReadLine();
switch (inputListStr)
{
case "1":
i_GarageManager.PrintFilteredVehicleList(eVehicleStatus.InRepair);
break;
case "2":
i_GarageManager.PrintFilteredVehicleList(eVehicleStatus.Repaired);
break;
case "3":
i_GarageManager.PrintFilteredVehicleList(eVehicleStatus.Piad);
break;
default:
i_GarageManager.PrintVehicleList();
break;
}
}
public static void Main()
{
GarageManager LogicManager = new GarageManager();
GarageConsoleUI Mygarager = new GarageConsoleUI(LogicManager);
Mygarager.RunGarageProgram();
}
public static void Main(string[] args)
{
Garage newGarage = new Garage();
GarageManager newGarageManager = new GarageManager(newGarage);
newGarageManager.Service();
}
// Update the vehicle Status;
private static void UpdateVehicleStatus(GarageManager i_GarageManager)
{
string VehicleLicenseNum = getNewLicenseNum();
int indexOnList = i_GarageManager.IndexOfVehicle(VehicleLicenseNum);
if (indexOnList == -1)
{
Console.WriteLine("Vehicle L.N " + VehicleLicenseNum + " is not in the garage ");
}
else
{
Console.WriteLine("choose the status you wish to update vehicle :\n" +
"(1)In repair " + "(2)Repaired " + "(3)Payed " + "(any other key)other");
string inputListStr = Console.ReadLine();
switch (inputListStr)
{
case "1":
i_GarageManager.UpdateVehicleStatus(VehicleLicenseNum, eVehicleStatus.InRepair);
break;
case "2":
i_GarageManager.UpdateVehicleStatus(VehicleLicenseNum, eVehicleStatus.Repaired);
break;
case "3":
i_GarageManager.UpdateVehicleStatus(VehicleLicenseNum, eVehicleStatus.Piad);
break;
default:
// Do nothing , open for future options.
break;
}
}
}
internal void Run()
{
eInstructionOption currentInstreuction;
int nextInstruction = 0;
string garageName;
garageName = Comunicator.GreetUser();
this.m_Manager = new GarageManager(garageName);
while (true)
{
try
{
nextInstruction = Comunicator.GetInstructionFromUser();
switch (nextInstruction)
{
case 1:
this.m_Manager.AddNewVehicle();
Printer.PrintUpdateSuccessfully(eInstructionOption.AddNewVehicle);
break;
case 2:
this.m_Manager.FillEnergyInVehicle();
Printer.PrintUpdateSuccessfully(eInstructionOption.FuelOrChargeVehicle);
break;
case 3:
this.m_Manager.CheckVehicleState();
break;
case 4:
this.m_Manager.ChangeVehicleState();
Printer.PrintUpdateSuccessfully(eInstructionOption.ChangeVehicleState);
break;
case 5:
this.m_Manager.InflateWheels();
Printer.PrintUpdateSuccessfully(eInstructionOption.InflateWheels);
break;
case 6:
this.m_Manager.GetVehicleDetails();
break;
case 7:
this.m_Manager.ShowLicencePlatesInGarageByFilter();
break;
default:
Printer.PrintBadChosenOptionMessage();
break;
}
}
catch (FormatException e)
{
Printer.PrintMessage(e.Message);
}
}
}
private int getEnumValue(string i_question, Type i_enumType)
{
Console.WriteLine(i_question);
string enumTypeString = GarageManager.PrintEnumValues(i_enumType);
Console.WriteLine(enumTypeString);
return(getValidInputForIntVarriable(k_MinIndexForEnums, Enum.GetValues(i_enumType).Length));
}
internal void Run()
{
int instructionIndex = 0;
this.m_Manager = new GarageManager();
while (true)
{
try
{
instructionIndex = ChatBot.GreetUser();
switch (instructionIndex)
{
case 1:
this.m_Manager.AddNewVehicle();
break;
case 2:
this.m_Manager.PrintLicencePlatesInGarageByFilter();
break;
case 3:
this.m_Manager.ChangeVehicleStatus();
break;
case 4:
this.m_Manager.InflateWheels();
break;
case 5:
this.m_Manager.FillEnergyInVehicle(true); // For fuel
break;
case 6:
this.m_Manager.FillEnergyInVehicle(false); // For electric
break;
case 7:
this.m_Manager.GetVehicleDetails();
break;
default:
Console.WriteLine("You didn't choose a valid option");
break;
}
}
catch (FormatException e)
{
Console.WriteLine(e.Message);
}
}
}
public static void Main()
{
VehicleInitialDetails setup = CreateNewSetup();
GarageManager gm = new GarageManager();
bool exists = gm.CheckIfVehicleExists("12221C");
gm.AddNewVehicle(setup);
exists = gm.CheckIfVehicleExists("12221C");
gm.ChangeVehicleRepairState("12221C", eRepairState.Fixed);
gm.FillTyrePressure("12221C");
gm.RefuelVehicle("12221C", Fuel.eFuelType.Octan98, 30f);
}
// Printing vehicle info
private static void PrintVehicleInfo(GarageManager i_GarageManager)
{
string VehicleLicenseNum = getNewLicenseNum();
int indexOnList = i_GarageManager.IndexOfVehicle(VehicleLicenseNum);
if (indexOnList == -1)
{
Console.WriteLine("Vehicle L.N " + VehicleLicenseNum + " is not in the garage so we can't print his info");
}
else
{
i_GarageManager.PrintVehicleInfo(VehicleLicenseNum);
}
}
private void ShowLicensePlates()
{
StringBuilder filterMessage = new StringBuilder();
filterMessage.Append(string.Format("{0}0-No filter ", GarageManager.PrintEnumValues(typeof(ClientData.eVehicleStatusInGarage)), Environment.NewLine));
Console.WriteLine(filterMessage);
int userInput = getValidInputForIntVarriable(0, Enum.GetValues(typeof(ClientData.eVehicleStatusInGarage)).Length);
List <string> licenses = m_GarageManager.GetLicensePlatesAccordingToStatus(userInput);
foreach (string license in licenses)
{
Console.WriteLine(license);
}
Console.WriteLine(k_SuccessMessage);
}
public static void CheckIfRepowerArgsExceptions(string i_LicensePlate, float i_RepowerAmount, bool i_IsFuelEngine, GarageManager i_GarageManager, string i_MainClientLicensePlate, FueledEngine.eFuelType i_FuelType = FueledEngine.eFuelType.None)
{
GarageClient o_Client = null;
GarageClient.SingleVehicleInfo o_InnerDict = null;
if (i_GarageManager.m_GarageDictonary.TryGetValue(i_MainClientLicensePlate, out o_Client))
{
if (!o_Client.m_Vehicles.TryGetValue(i_LicensePlate, out o_InnerDict))
{
throw new Exception("license plate was not found in the garage");
}
}
if (o_InnerDict.m_Vehicle.m_Engine.GetEngineType() == Engine.eEngineType.Electric && i_IsFuelEngine)
{
throw new Exception("vehicle cannot be charged because it is not a fueled vehicle");
}
if (o_InnerDict.m_Vehicle.m_Engine.GetEngineType() == Engine.eEngineType.Fuel && !i_IsFuelEngine)
{
throw new Exception("vehicle cannot be charged because it is not an electric vehicle");
}
if (i_RepowerAmount > o_InnerDict.m_Vehicle.m_Engine.getMaxPowerAmount())
{
if (i_IsFuelEngine)
{
throw new Exception("Fuel amount requested is greater than the fuel tank capacity");
}
else
{
throw new Exception("charge time requested is greater than the max charge time possible");
}
}
if (o_InnerDict.m_Vehicle.m_Engine is FueledEngine)
{
FueledEngine currentFueledEngine = (FueledEngine)o_InnerDict.m_Vehicle.m_Engine;
if (currentFueledEngine.GetFuelType() != i_FuelType)
{
throw new Exception(string.Format("Fuel type requested, does not match the fuel type of this vehicle ({0}).", currentFueledEngine.GetFuelType()));
}
}
}
public GarageConsoleUI(GarageManager i_LogicManager)
{
this.m_LogicManager = i_LogicManager;
}
internal UserInterface()
{
m_Garage = new GarageManager();
}
public UI()
{
r_GarageManager = new GarageManager();
r_Screens = getScreens();
}
public UserInterface()
{
m_GarageManager = new GarageManager();
m_InputValidation = new InputValidation();
}
public static void Main()
{
GarageManager garageManagment = new GarageManager();
garageManagment.OpenGarage();
}
public ApplicationManager()
{
m_GarageManager = new GarageManager();
}
public UI()
{
this.m_GarageManager = new GarageManager();
this.m_CurrentClient = null;
}
public static void Main()
{
GarageManager myGarage = new GarageManager();
myGarage.start();
}
static void Main()
{
GarageManager myGarage = new GarageManager();
myGarage.Run();
}
public static GarageManager.eSupportedVehciles ParseVehicleTypeInput(string i_Input, GarageManager i_GarageManager)
{
GarageManager.eSupportedVehciles vehicleTypeInput = 0;
GarageManager.eSupportedVehciles typeOfInput = 0;
try
{
typeOfInput = (GarageManager.eSupportedVehciles)Enum.Parse(typeof(GarageManager.eSupportedVehciles), i_Input);
}
catch
{
throw new FormatException("Invalid input, must be a valid vehicle");
}
switch (typeOfInput)
{
case GarageManager.eSupportedVehciles.ElectricBike:
vehicleTypeInput = GarageManager.eSupportedVehciles.ElectricBike;
break;
case GarageManager.eSupportedVehciles.ElectricCar:
vehicleTypeInput = GarageManager.eSupportedVehciles.ElectricCar;
break;
case GarageManager.eSupportedVehciles.FueledBike:
vehicleTypeInput = GarageManager.eSupportedVehciles.FueledBike;
break;
case GarageManager.eSupportedVehciles.FueledCar:
vehicleTypeInput = GarageManager.eSupportedVehciles.FueledCar;
break;
case GarageManager.eSupportedVehciles.Truck:
vehicleTypeInput = GarageManager.eSupportedVehciles.Truck;
break;
default:
throw new FormatException("Invalid input, you must enter a number (1-5) represting a supported vehicle");
}
return(vehicleTypeInput);
}
// Constractor for UIManager.
public UIManager()
{
m_GarageManager = new GarageManager();
}
private void ChangeVehicleStatus()
{
string changeStatusMessage = string.Format("Please Enter a Licance number");
string licensePlate;
if (SearchVehicle(changeStatusMessage, out licensePlate))
{
int maxStatusNumber = Enum.GetValues(typeof(ClientData.eVehicleStatusInGarage)).Length;
string statusMessage = string.Format("Please enter a new status to update{0} {1}", Environment.NewLine, GarageManager.PrintEnumValues(typeof(ClientData.eVehicleStatusInGarage)));
Console.WriteLine(statusMessage);
int userInput = getValidInputForIntVarriable(1, maxStatusNumber);
m_GarageManager.ChangeStatusOfVehicle(licensePlate, (ClientData.eVehicleStatusInGarage)userInput);
Console.WriteLine(k_SuccessMessage);
}
}
private void RefuelVehicle()
{
try
{
string refuelVehicleMessage = "Enter a license number for a vehicle to refuel";
string licensePlate;
if (SearchVehicle(refuelVehicleMessage, out licensePlate))
{
Vehicle customerVehicle = m_GarageManager.FindClient(licensePlate).vehicle;
if (customerVehicle.engine is FuelEngine)
{
int numOfFuelTypes = Enum.GetValues(typeof(FuelEngine.eFuelType)).Length;
string fuelTypeMessage = string.Format("Which fuel type should we use?{0}{1}", Environment.NewLine, GarageManager.PrintEnumValues(typeof(FuelEngine.eFuelType)));
Console.WriteLine(fuelTypeMessage);
int userInputForFuelType = getValidInputForIntVarriable(1, numOfFuelTypes);
string amountTorefillMessage = "How much fuel do you wish to add?";
Console.WriteLine(amountTorefillMessage);
float amountToRefull;
while (!float.TryParse(Console.ReadLine(), out amountToRefull))
{
Console.WriteLine(k_InvalidRangeMessage);
}
m_GarageManager.RefuelSpecificVehicle(licensePlate, (FuelEngine.eFuelType)userInputForFuelType, amountToRefull);
Console.WriteLine(k_SuccessMessage);
}
else
{
Console.WriteLine(k_WrongEngineMessage);
}
}
}
catch (ValueOutOfRangeException)
{
Console.WriteLine("Wrong amount to refuel, the amount entered was too much");
}
catch (ArgumentException)
{
Console.WriteLine("Wrong fuel type entered");
}
}
public static void Main()
{
s_GarageManager = new GarageManager();
startNewService();
}
public GarageUi()
{
r_CurrentGarage = new GarageManager();
}
public GarageConsoleUI()
{
r_GarageManager = new GarageManager();
Console.ForegroundColor = ConsoleColor.White;
m_SystemStatus = eSystemStatus.On;
}
// The main method that run our garage
public void StartService()
{
GarageManager newGarageManager = this.m_GarageManager;
bool isDone = false;
while (isDone == false)
{
// User choose the service he wish for.
eService serviceOptionChoose = ServiceOptionChoose(newGarageManager.m_ServiceList);
switch (serviceOptionChoose)
{
case eService.AddVehical:
string VehicleLicenseNum = getNewLicenseNum();
int indexOnList = newGarageManager.IndexOfVehicle(VehicleLicenseNum);
if (indexOnList != -1)
{
Console.WriteLine("Vehicle L.N " + VehicleLicenseNum +
" is allready in the garage and his status is " + newGarageManager.VehicleList[indexOnList].VehicleStatus);
}
else
{
newGarageManager.VehicleList.Add(GetNewVehicleStatusInfo(VehicleLicenseNum));
}
break;
case eService.PrintVehicalList:
PrintVehicleList(newGarageManager);
break;
case eService.UpdateVehicleStatus:
UpdateVehicleStatus(newGarageManager);
break;
case eService.FillAirInWheels:
string licenseOfVehicleToFillAir = getNewLicenseNum();
if (newGarageManager.IsInGarage(licenseOfVehicleToFillAir))
{
newGarageManager.FillAir(licenseOfVehicleToFillAir);
Console.WriteLine("We filled your wheels with air !");
}
else
{
Console.WriteLine("No such vehicle in the garage with this License number");
}
break;
case eService.FuelUpTank:
string licenseNumberForFuel = getNewLicenseNum();
if (newGarageManager.IsInGarage(licenseNumberForFuel))
{
Vehicle vehicleToFuel = newGarageManager.VehicleList[newGarageManager.IndexOfVehicle(licenseNumberForFuel)].Vehicle;
if (vehicleToFuel.EngineEnergyType != eEnergyType.Electricity)
{
eEnergyType energyTypeToFuel = getEnergyType();
float fuelToFill = ChooseNumOf("of fuel amount");
newGarageManager.AddEnergy(licenseNumberForFuel, energyTypeToFuel, fuelToFill);
}
else
{
Console.Write("we are sorry but we cannot feul up a the vehicle with fuel since he use battery ! send him to charging.");
}
}
else
{
Console.WriteLine("No such vehicle in the garage with this License number");
}
break;
case eService.ChargeUpBattery:
string licenseNumberForCharge = getNewLicenseNum();
if (newGarageManager.IsInGarage(licenseNumberForCharge))
{
Vehicle vehicleToCharge = newGarageManager.VehicleList[newGarageManager.IndexOfVehicle(licenseNumberForCharge)].Vehicle;
if (vehicleToCharge.EngineEnergyType == eEnergyType.Electricity)
{
eEnergyType energyTypeToFuel = eEnergyType.Electricity;
float batteryToCharge = ChooseNumOf("of battery time to charge");
newGarageManager.AddEnergy(licenseNumberForCharge, energyTypeToFuel, batteryToCharge);
}
else
{
Console.Write("we are sorry but we cannot Charge up a the motoric vehcile since he use Fuel ! send him to fueling tank.");
}
}
else
{
Console.WriteLine("No such vehicle in the garage with this License number");
}
break;
case eService.PrintVehicleInfo:
PrintVehicleInfo(newGarageManager);
break;
case eService.Done:
Console.WriteLine("Thanks for using our service, have a nice day and good bye!");
isDone = true;
break;
default:
Console.WriteLine("Please choose a valide option from our service");
break;
}
Console.WriteLine("\n\n");
}
}
public static void Main()
{
GarageManager manager = new GarageManager();
manager.Start();
}
public UserInterface()
{
GM = new GarageManager();
}
