/// <summary>
/// Metoden hanterar inmatning av kommandon från ui
/// </summary>
/// <param name="iNumberOfGarageHandlers">Antalet garagehandler som det finns</param>
/// <returns>enum MenuInputResult med olika värden beroende på användarens kommando. Index till vald garagehandler</returns>
private (MenuInputResult result, int iSelectedGarageHandler) HandleInput(int iNumberOfGarageHandlers)
{
MenuInputResult result = MenuInputResult.NA;
int iSelectedGarageHandler = 0;
// Inläsning av vald siffra
string strInput = this.Ui.ReadLine();
if (!String.IsNullOrWhiteSpace(strInput))
{
strInput = strInput.Trim();
if (strInput.StartsWith('0'))
{// Användaren har valt att avsluta programmet. Återgå till huvudmenyn
result = MenuInputResult.TO_MAIN_MENU;
}
else
{
if (Int32.TryParse(strInput, out iSelectedGarageHandler) && iSelectedGarageHandler > 0 && iSelectedGarageHandler <= iNumberOfGarageHandlers)
{// Användaren har valt ett giltig index till en garageHandler. Nu vill jag återgå till main menu med detta index
result = MenuInputResult.TO_MAIN_MENU;
}
else
{
result = MenuInputResult.WRONG_INPUT;
}
}
}
else
{
result = MenuInputResult.TO_MAIN_MENU;
}
return(result : result, iSelectedGarageHandler : iSelectedGarageHandler);
}
/// <summary>
/// Metoden söker efter fordon med ett antal hjul
/// </summary>
/// <returns>enum MenuInputResult med olika värden beroende på användarens kommando</returns>
private MenuInputResult SearchForVehicleWithNumberOfWheels()
{
int iNumberOfWheels = 0;
MenuInputResult result = MenuInputResult.NA;
this.Ui.Clear();
this.Ui.WriteLine(this.MenuFactory.GetMenu(MenuType.SEARCH_VEHICLE_WITH_NUMBER_OF_WHEELS));
// Inläsning av sökt registreringsnummer från användaren
string strInput = this.Ui.ReadLine();
if (!String.IsNullOrWhiteSpace(strInput))
{
strInput = strInput.Trim();
if (strInput.Length == 1 && strInput.StartsWith('0'))
{// Användaren har valt att avsluta programmet. Återgå till menyn
result = MenuInputResult.TO_GARAGE_MENU;
return(result);
}
else
{
if (Int32.TryParse(strInput, out iNumberOfWheels))
{// Antal hjul var en siffra
// Hämta vald garagehandler
IGarageHandler garageHandler = this.GarageHandlers.FirstOrDefault(g => g.GuidId.Equals(this.SelectedGarageHandlerGuid));
if (garageHandler != null)
{
var lsVehicles = garageHandler.Garage.Where(vv => ((WheeledVehicle)vv).NumberOfWheels == iNumberOfWheels).ToList();
if (lsVehicles?.Count > 0)
{
foreach (var vehicle in lsVehicles)
{
Ui.WriteLine(vehicle.ToString());
}
}
else
{
Ui.WriteLine($"Hittade inga fordon med {iNumberOfWheels} hjul");
}
Ui.WriteLine("Return för att fortsätta");
Ui.ReadLine();
}
}
else
{
result = MenuInputResult.WRONG_INPUT;
}
}
}
else
{
result = MenuInputResult.WRONG_INPUT;
}
return(result);
}
/// <summary>
/// Metod som kör programmet
/// Visar programmets huvudmeny
/// </summary>
public void Run()
{
MenuInputResult result = MenuInputResult.NA;
MainMenu mainMenu = new MainMenu(this.MenuFactory, this.Ui, this.lsGarageHandlers, this.RegistrationNumberRegister);
do
{
result = mainMenu.Show();
}while (result != MenuInputResult.EXIT);
}
/// <summary>
/// Metoden visar menyn för att välja garage
/// </summary>
/// <returns>Index för valt garage eller 0 för ej valt garage</returns>
public int Show()
{
MenuInputResult result = MenuInputResult.NA;
int iSelectedGarageHandler = 0;
do
{
this.Ui.Clear();
if (result == MenuInputResult.WRONG_INPUT)
{
this.Ui.WriteLine("Felaktig inmatning");
}
result = MenuInputResult.NA;
this.Ui.WriteLine(this.MenuFactory.GetMenu(MenuType.SELECT_GARAGE_MENU));
// Nu skall jag skapa meny valen för varje garageHandler
string strIsFull = String.Empty;
int iCount = 1;
if (GarageHandlers.Count > 0)
{
foreach (IGarageHandler garageHandler in GarageHandlers)
{
// Hämta uppgifter om garaget
var(strId, strName, bIsFull, iCapacity, iNumberOfParkedVehicle) = garageHandler.GetGarageInfo();
// Skapa en lämplig utskrift för menyn
strIsFull = bIsFull ? "Nej" : "Ja";
Ui.WriteLine($"{iCount}. {strName}. Har lediga platser {strIsFull}");
iCount++;
}
// Hantera inmatning från användaren
var(returnResult, iReturnSelectedGarageHandler) = HandleInput(GarageHandlers.Count);
result = returnResult;
if (result != MenuInputResult.WRONG_INPUT)
{
iSelectedGarageHandler = iReturnSelectedGarageHandler;
}
}
else
{
result = MenuInputResult.TO_MAIN_MENU;
Ui.WriteLine("Det finns inga garage");
Ui.WriteLine("Return för att fortsätta");
Ui.ReadLine();
}
}while (result != MenuInputResult.TO_MAIN_MENU);
return(iSelectedGarageHandler);
}
/// <summary>
/// Metoden hantera input från användaren
/// </summary>
/// <returns>enum MenuInputResult med olika värden beroende på användarens kommando</returns>
private MenuInputResult HandleInput()
{
MenuInputResult result = MenuInputResult.NA;
// Inläsning av information från användaren
string strInput = this.Ui.ReadLine();
if (!String.IsNullOrWhiteSpace(strInput))
{
strInput = strInput.Trim();
if (strInput.StartsWith('0'))
{// Användaren har valt att avsluta programmet. Återgå till menyn
result = MenuInputResult.TO_GARAGE_MENU;
return(result);
}
else if (strInput.StartsWith('1'))
{// Sök på registreringsnummer
result = SearchForVehicleWithRegistrationsNumber();
}
else if (strInput.StartsWith('2'))
{// Sök på upptagna registreringsnummer
result = SearchForUsedRegistrationsNumber();
}
else if (strInput.StartsWith('3'))
{// Sök på färg
result = SearchForVehicleWithColor();
}
else if (strInput.StartsWith('4'))
{// Sök på fordonstyp
result = SearchForVehicleOfType();
}
else if (strInput.StartsWith('5'))
{// Sök på antal hjul
result = SearchForVehicleWithNumberOfWheels();
}
else if (strInput.StartsWith('6'))
{// Sök på antal sittande passagerare
result = SearchForVehicleWithNumberOfSeatedPassenger();
}
else if (strInput.StartsWith('7'))
{// Sök på en text
result = SearchForVehicleWithText();
}
else
{
result = MenuInputResult.WRONG_INPUT;
}
}
else
{
result = MenuInputResult.WRONG_INPUT;
}
return(result);
}
/// <summary>
/// Metod för att söka fordon med en speciell färg
/// </summary>
/// <returns>enum MenuInputResult med olika värden beroende på användarens kommando</returns>
private MenuInputResult SearchForVehicleWithColor()
{
MenuInputResult result = MenuInputResult.NA;
this.Ui.Clear();
this.Ui.WriteLine(this.MenuFactory.GetMenu(MenuType.SEARCH_VEHICLE_WITH_COLOR));
// Inläsning av sökt färg från användaren
string strInput = this.Ui.ReadLine();
if (!String.IsNullOrWhiteSpace(strInput))
{
strInput = strInput.Trim();
if (strInput.Length == 1 && strInput.StartsWith('0'))
{// Användaren har valt att avsluta programmet. Återgå till menyn
result = MenuInputResult.TO_GARAGE_MENU;
return(result);
}
else
{
strInput = strInput.ToUpper();
// Hämta vald garagehandler
IGarageHandler garageHandler = this.GarageHandlers.FirstOrDefault(g => g.GuidId.Equals(this.SelectedGarageHandlerGuid));
if (garageHandler != null)
{
var lsVehicles = garageHandler.Garage.Where(v => ((IVehicle)v).Color.CompareTo(strInput) == 0).ToList();
if (lsVehicles?.Count > 0)
{
foreach (var vehicle in lsVehicles)
{
Ui.WriteLine(vehicle.ToString());
}
}
else
{
Ui.WriteLine($"Hittade inga fordon med färgen {strInput.ToLower().FirstToUpper()}");
}
Ui.WriteLine("Return för att fortsätta");
Ui.ReadLine();
}
}
}
else
{
result = MenuInputResult.WRONG_INPUT;
}
return(result);
}
/// <summary>
/// Metoden hanterar inmatning av kommandon från ui
/// </summary>
/// <returns>enum MenuInputResult med olika värden beroende på användarens kommando</returns>
private MenuInputResult HandleInput()
{
MenuInputResult result = MenuInputResult.NA;
// Inläsning av kommando från ui
string strInput = this.Ui.ReadLine();
if (!String.IsNullOrWhiteSpace(strInput))
{
strInput = strInput.Trim();
if (strInput.StartsWith('0'))
{// Användaren har valt att avsluta programmet. Återgå till huvudmenyn
result = MenuInputResult.TO_MAIN_MENU;
}
else if (strInput.StartsWith('1'))
{// Skapa och parkera ett fordon
CreateAndParkVehicleMenu createAndParkVehicleMenu = new CreateAndParkVehicleMenu(this.MenuFactory, this.Ui, this.GarageHandlers, this.SelectedGarageHandlerGuid, this.RegistrationNumberRegister);
result = createAndParkVehicleMenu.Show();
}
else if (strInput.StartsWith('2'))
{// Lämna garaget med ett fordon
LeaveTheGarageMenu leaveTheGarageMenu = new LeaveTheGarageMenu(this.MenuFactory, this.Ui, this.GarageHandlers, this.SelectedGarageHandlerGuid, this.RegistrationNumberRegister);
result = leaveTheGarageMenu.Show();
}
else if (strInput.StartsWith('3'))
{// Skapa ett antal fordon
Simulering();
//Simulering(6);
}
else if (strInput.StartsWith('4'))
{// Lista alla fordon
ListAllVehicle();
}
else if (strInput.StartsWith('5'))
{// Lista alla fordon per typ
ListAllVehicleByType();
}
else if (strInput.StartsWith('6'))
{// Sök efter fordon
SearchVehicleMenu searchVehicleMenu = new SearchVehicleMenu(this.MenuFactory, this.Ui, this.GarageHandlers, this.SelectedGarageHandlerGuid, this.RegistrationNumberRegister);
result = searchVehicleMenu.Show();
}
}
else
{
result = MenuInputResult.TO_GARAGE_MENU;
}
return(result);
}
/// <summary>
/// Metod för att låta användaren söka efter fordon på registreringsnumret
/// </summary>
/// <returns>enum MenuInputResult med olika värden beroende på användarens kommando</returns>
private MenuInputResult SearchForVehicleWithRegistrationsNumber()
{
MenuInputResult result = MenuInputResult.NA;
int iCount = 0;
this.Ui.Clear();
this.Ui.WriteLine(this.MenuFactory.GetMenu(MenuType.SEARCH_VEHICLE_WITH_REGISTRATIONNUMBER));
// Inläsning av sökt registreringsnummer från användaren
string strInput = this.Ui.ReadLine();
if (!String.IsNullOrWhiteSpace(strInput))
{
strInput = strInput.Trim();
if (strInput.Length == 1 && strInput.StartsWith('0'))
{// Användaren har valt att avsluta programmet. Återgå till menyn
result = MenuInputResult.TO_GARAGE_MENU;
return(result);
}
else
{
strInput = strInput.ToUpper();
// Hämta vald garagehandler
IGarageHandler garageHandler = this.GarageHandlers.FirstOrDefault(g => g.GuidId.Equals(this.SelectedGarageHandlerGuid));
if (garageHandler != null)
{
// Det skall bara finnas ett fordon med registreringsnummer
var vehicle = garageHandler.Garage.FirstOrDefault(v => ((IVehicle)v).RegistrationNumber.CompareTo(strInput) == 0);
if (vehicle != null)
{
Ui.WriteLine(vehicle.ToString());
}
else
{
Ui.WriteLine("Hittade inga fordon med sökt registreringsnummer");
}
Ui.WriteLine("Return för att fortsätta");
Ui.ReadLine();
}
}
}
else
{
result = MenuInputResult.WRONG_INPUT;
}
return(result);
}
/// <summary>
/// Metoden läser in fordonets färg från användaren. Användaren kan också välja att använd den default färgen
/// </summary>
/// <param name="strDefaultColor">Default färg</param>
/// <returns>MenuInputResult och fordonets färg</returns>
private (MenuInputResult menuInputResult, string strColor) GetColor(string strDefaultColor)
{
MenuInputResult result = MenuInputResult.NA;
string strColor = strDefaultColor.ToUpper();
string strInput = String.Empty;
string strColorMenu = String.Empty;
bool bRun = true;
do
{
this.Ui.Clear();
if (result == MenuInputResult.WRONG_INPUT)
{
this.Ui.WriteLine("Felaktig inmatning");
}
result = MenuInputResult.NA;
// Visa menyn. Lite special för att kunna få med default färg
strColorMenu = this.MenuFactory.GetMenu(MenuType.CREATE_COLOR);
strColorMenu = strColorMenu + ". (Default är " + strColor + ")" + System.Environment.NewLine;
this.Ui.WriteLine(strColorMenu);
// Inläsning av fordonets färg från användarna
strInput = this.Ui.ReadLine();
if (!String.IsNullOrWhiteSpace(strInput))
{
strInput = strInput.Trim();
if (strInput.Length == 1 && strInput.StartsWith('0'))
{// Användaren har valt att avsluta programmet. Återgå till menyn
result = MenuInputResult.TO_GARAGE_MENU;
return(result, strColor);
}
else if (strInput.Length == 1 && strInput.StartsWith('1'))
{// Användaren har valt den defaulta färgen
strInput = strDefaultColor.ToString();
}
strColor = strInput.ToUpper();
result = MenuInputResult.CONTINUE;
bRun = false;
}
else
{
result = MenuInputResult.WRONG_INPUT;
}
} while (bRun);
return(result, strColor);
}
/// <summary>
/// Metod för att låta användaren söka efter upptaget registreringsnumret
/// </summary>
/// <returns>enum MenuInputResult med olika värden beroende på användarens kommando</returns>
private MenuInputResult SearchForUsedRegistrationsNumber()
{
MenuInputResult result = MenuInputResult.NA;
this.Ui.Clear();
this.Ui.WriteLine(this.MenuFactory.GetMenu(MenuType.SEARCH_FOR_USED_REGISTRATIONNUMBER));
// Inläsning av sökt registreringsnummer från användaren
string strInput = this.Ui.ReadLine();
if (!String.IsNullOrWhiteSpace(strInput))
{
strInput = strInput.Trim();
if (strInput.Length == 1 && strInput.StartsWith('0'))
{// Användaren har valt att avsluta programmet. Återgå till menyn
result = MenuInputResult.TO_GARAGE_MENU;
return(result);
}
else
{
strInput = strInput.ToUpper();
if (this.RegistrationNumberRegister.CheckIfRegistrationNumberExists(strInput))
{
Ui.WriteLine($"Registreringsnummer {strInput} är upptaget");
}
else
{
Ui.WriteLine($"Registreringsnummer {strInput} är ledigt");
}
Ui.WriteLine("Return för att fortsätta");
Ui.ReadLine();
}
}
else
{
result = MenuInputResult.WRONG_INPUT;
}
return(result);
}
/// <summary>
/// Metoden visar huvudmenyn
/// </summary>
/// <returns>enum MenuInputResult med olika värden beroende på användarens kommando</returns>
public MenuInputResult Show()
{
MenuInputResult result = MenuInputResult.NA;
do
{
this.Ui.Clear();
if (result == MenuInputResult.WRONG_INPUT)
{
this.Ui.WriteLine("Felaktig inmatning");
}
result = MenuInputResult.NA;
this.Ui.WriteLine(this.MenuFactory.GetMenu(MenuType.MAIN_MENU));
result = HandleInput();
}while (result != MenuInputResult.EXIT);
return(result);
}
/// <summary>
/// Metoden visar menyerna där användaren kan skapa ett nytt garage
/// </summary>
/// <returns>enum MenuInputResult med olika värden beroende på användarens kommando</returns>
public MenuInputResult Show()
{
MenuInputResult result = MenuInputResult.NA;
do
{
this.Ui.Clear();
if (result == MenuInputResult.WRONG_INPUT)
{
this.Ui.WriteLine("Felaktig inmatning");
}
result = MenuInputResult.NA;
this.Ui.WriteLine(this.MenuFactory.GetMenu(MenuType.CREATE_GARAGE_MENU));
// Hantera inmatning från användaren
result = HandleInput();
}while (result != MenuInputResult.TO_MAIN_MENU);
return(result);
}
/// <summary>
/// Metoden visar menyer där användaren kan välja vad hen vill göra med ett garage
/// </summary>
/// <returns>enum MenuInputResult med olika värden beroende på användarens kommando</returns>
public MenuInputResult Show()
{
MenuInputResult result = MenuInputResult.NA;
do
{
this.Ui.Clear();
if (result == MenuInputResult.WRONG_INPUT)
{
this.Ui.WriteLine("Felaktig inmatning");
}
result = MenuInputResult.NA;
// Hämta vald garagehandler
IGarageHandler garageHandler = this.GarageHandlers.FirstOrDefault(g => g.GuidId.Equals(this.SelectedGarageHandlerGuid));
if (garageHandler != null)
{
var(strId, strName, bIsFull, iCapacity, iNumberOfParkedVehicle) = garageHandler.GetGarageInfo();
// Skapa en lämplig utskrift för menyn
string strIsFull = bIsFull ? "Nej" : "Ja";
this.Ui.WriteLine($"{strName}. Har lediga platser {strIsFull}. Antal bilar i garaget {iNumberOfParkedVehicle}");
}
// Visa menyn
this.Ui.WriteLine(this.MenuFactory.GetMenu(MenuType.GARAGE_MENU));
// Hantera inmatning från användaren
result = HandleInput();
}while (result != MenuInputResult.TO_MAIN_MENU);
return(result);
}
/// <summary>
/// Metoden hantera input från användaren
/// </summary>
/// <returns>enum MenuInputResult med olika värden beroende på användarens kommando</returns>
private MenuInputResult HandleInput()
{
IVehicle tmpVehicle = null;
MenuInputResult result = MenuInputResult.TO_GARAGE_MENU;
// Hämta vald garagehandler
IGarageHandler garageHandler = this.GarageHandlers.FirstOrDefault(g => g.GuidId.Equals(this.SelectedGarageHandlerGuid));
if (garageHandler != null)
{
// Inläsning av information från användaren
string strInput = this.Ui.ReadLine();
if (!String.IsNullOrWhiteSpace(strInput))
{
strInput = strInput.Trim();
if (strInput.StartsWith('0'))
{// Användaren har valt att avsluta programmet. Återgå till menyn
result = MenuInputResult.TO_GARAGE_MENU;
return(result);
}
else if (strInput.StartsWith('1'))
{// Skapa en bil
var(menuInputResult, newVehicle) = CreateVehicle(Vehicle_Type.CAR);
result = menuInputResult;
if (result == MenuInputResult.TO_GARAGE_MENU)
{
return(result);
}
if (newVehicle != null)
{
// Parkera fordonet
if (ParkVehicleInGarage(newVehicle) == true)
{// Det gick parkera fordonet. Nu skall vi registrerar att registreringsnumret är upptaget
tmpVehicle = newVehicle as IVehicle;
if (tmpVehicle != null)
{
// Nu behöver jag lägga till registreringsnumret till de upptagna registreringsnumren
this.RegistrationNumberRegister.AddRegistrationNumber(tmpVehicle.RegistrationNumber);
}
}
}
else
{
if (menuInputResult == MenuInputResult.CREATE_VEHICLE_FAILED)
{
Ui.WriteLine("Det gick inte att skapa ett fordon");
}
}
Ui.WriteLine("Return för att fortsätta");
Ui.ReadLine();
}
else if (strInput.StartsWith('2'))
{// Skapa en buss
var(menuInputResult, newVehicle) = CreateVehicle(Vehicle_Type.BUS);
result = menuInputResult;
if (result == MenuInputResult.TO_GARAGE_MENU)
{
return(result);
}
if (newVehicle != null)
{
// Parkera fordonet
if (ParkVehicleInGarage(newVehicle) == true)
{// Det gick parkera fordonet. Nu skall vi registrerar att registreringsnumret är upptaget
tmpVehicle = newVehicle as IVehicle;
if (tmpVehicle != null)
{
// Nu behöver jag lägga till registreringsnumret till de upptagna registreringsnumren
this.RegistrationNumberRegister.AddRegistrationNumber(tmpVehicle.RegistrationNumber);
}
}
}
else
{
if (menuInputResult == MenuInputResult.CREATE_VEHICLE_FAILED)
{
Ui.WriteLine("Det gick inte att skapa ett fordon");
}
}
Ui.WriteLine("Return för att fortsätta");
Ui.ReadLine();
}
else if (strInput.StartsWith('3'))
{// Skapa en motorcykel
var(menuInputResult, newVehicle) = CreateVehicle(Vehicle_Type.MOTORCYCLE);
result = menuInputResult;
if (result == MenuInputResult.TO_GARAGE_MENU)
{
return(result);
}
if (newVehicle != null)
{
// Parkera fordonet
if (ParkVehicleInGarage(newVehicle) == true)
{// Det gick parkera fordonet. Nu skall vi registrerar att registreringsnumret är upptaget
tmpVehicle = newVehicle as IVehicle;
if (tmpVehicle != null)
{
// Nu behöver jag lägga till registreringsnumret till de upptagna registreringsnumren
this.RegistrationNumberRegister.AddRegistrationNumber(tmpVehicle.RegistrationNumber);
}
}
}
else
{
if (menuInputResult == MenuInputResult.CREATE_VEHICLE_FAILED)
{
Ui.WriteLine("Det gick inte att skapa ett fordon");
}
}
Ui.WriteLine("Return för att fortsätta");
Ui.ReadLine();
}
else
{
result = MenuInputResult.WRONG_INPUT;
}
}
else
{
result = MenuInputResult.TO_GARAGE_MENU;
}
}
return(result);
}
/// <summary>
/// Metoden hanterar inmatning av kommandon från ui
/// Hantering av inmatning av namn på garage och dess kapacitet
/// </summary>
/// <returns>enum MenuInputResult med olika värden beroende på användarens kommando</returns>
private MenuInputResult HandleInput()
{
MenuInputResult result = MenuInputResult.NA;
// Inläsning av namnet på garaget
string strInput = this.Ui.ReadLine();
if (!String.IsNullOrWhiteSpace(strInput))
{
strInput = strInput.Trim();
if (strInput.StartsWith('0'))
{// Användaren har valt att avsluta programmet. Återgå till huvudmenyn
result = MenuInputResult.TO_MAIN_MENU;
}
else
{
// Nu har vi namnet på garaget
string strGarageName = strInput;
// Nu skall vi läsa in kapacitet
Ui.WriteLine("0. För att återgå till huvudmenyn");
Ui.WriteLine("Ange antal platser i garaget ");
int iCapacity = 0;
// Inläsning av garagets kapacitet
strInput = this.Ui.ReadLine();
if (!String.IsNullOrWhiteSpace(strInput))
{
strInput = strInput.Trim();
if (strInput.StartsWith('0'))
{// Användaren har valt att avsluta programmet. Återgå till huvudmenyn
result = MenuInputResult.TO_MAIN_MENU;
}
else
{
string strCapacity = strInput;
if (Int32.TryParse(strCapacity, out iCapacity) && iCapacity > 0)
{// Vi har en capacity
// Skapa ett nytt garage
IGarageFactory garageFactory = new GarageFactory();
IGarage <ICanBeParkedInGarage> garage = garageFactory.CreateGarage(Guid.NewGuid(), strGarageName, iCapacity);
// Skapa en handler som skall hantera det nya garaget
IGarageHandler garageHandler = new Excercise5Garage.GarageHandler.GarageHandler(garage, this.Ui);
// Lägg till handlern till en lista med olika garagehandlers
this.GarageHandlers.Add(garageHandler);
Ui.WriteLine("Skapade garage. " + garage);
Ui.WriteLine("Return för att återgå till huvudmenyn");
this.Ui.ReadLine();
result = MenuInputResult.TO_MAIN_MENU;
}
else
{
result = MenuInputResult.WRONG_INPUT;
}
}
}
else
{
result = MenuInputResult.WRONG_INPUT;
}
}
}
else
{
result = MenuInputResult.TO_MAIN_MENU;
}
return(result);
}
/// <summary>
/// Metoden hantera input från användaren
/// </summary>
/// <returns>enum MenuInputResult med olika värden beroende på användarens kommando</returns>
private MenuInputResult HandleInput()
{
int iRemovedNumberOfVehicle = 0;
MenuInputResult result = MenuInputResult.TO_GARAGE_MENU;
// Hämta vald garagehandler
IGarageHandler garageHandler = this.GarageHandlers.FirstOrDefault(g => g.GuidId.Equals(this.SelectedGarageHandlerGuid));
if (garageHandler != null)
{
if (garageHandler.Garage.Count() > 0)
{// Det finns fordon i Garaget
// Inläsning av vald siffra eller registreringsnummer
string strInput = this.Ui.ReadLine();
if (!String.IsNullOrWhiteSpace(strInput))
{
strInput = strInput.Trim();
if (strInput.Length == 1 && strInput.StartsWith('0'))
{// Användaren har valt att avsluta programmet. Återgå till huvudmenyn
result = MenuInputResult.TO_GARAGE_MENU;
}
else
{
strInput = strInput.ToUpper();
IVehicle tmpVehicle = null;
// Leta upp sökt fordon i garaget. Radera det. Om det gick radera skall vi även radera registreringsnumret från registret med upptagna registreringsnummer
foreach (ICanBeParkedInGarage vehicle in garageHandler.Garage)
{
tmpVehicle = vehicle as IVehicle;
if (tmpVehicle != null)
{
if (tmpVehicle.RegistrationNumber.CompareTo(strInput) == 0)
{ // Vi har hittat sökt fordon. Radera från garaget
if (garageHandler.RemoveVehicle(vehicle))
{ // Vi har raderat fordonet från garaget
// Radera registreringsnumret från registret av använda registreringsnummer
this.RegistrationNumberRegister.RemoveRegistrationNumber(tmpVehicle.RegistrationNumber);
iRemovedNumberOfVehicle++;
}
Ui.WriteLine("Return för att fortsätta");
Ui.ReadLine();
result = MenuInputResult.TO_GARAGE_MENU;
break;
}
}
}
if (iRemovedNumberOfVehicle == 0)
{
Ui.WriteLine("Bilen ni sökte finns inte i garaget");
Ui.WriteLine("Return för att fortsätta");
Ui.ReadLine();
result = MenuInputResult.TO_GARAGE_MENU;
}
}
}
else
{
result = MenuInputResult.TO_GARAGE_MENU;
}
}
else
{
Ui.WriteLine("Det finns inga fordon i garaget");
Ui.WriteLine("Return för att återgå till menyn");
Ui.ReadLine();
result = MenuInputResult.TO_GARAGE_MENU;
}
}
return(result);
}
/// <summary>
/// Metoden söker efter vehicle med en sök text.
/// Gör sökningen på ett antal properties och sammanställer resultatet
/// </summary>
/// <returns>enum MenuInputResult med olika värden beroende på användarens kommando</returns>
private MenuInputResult SearchForVehicleWithText()
{
// Listor med sök ord som har matchat något i sökningarna efter vehicle
List <string> lsMatchedRegistrationnumbers = new List <string>();
List <string> lsMatchedColors = new List <string>();
List <string> lsMatchedTypes = new List <string>();
List <int> lsMatchedNumberOfWheels = new List <int>();
List <int> lsMatchedNumberOfSeatedPassengers = new List <int>();
// Sammanställd lista med resultat av sökningen
List <ICanBeParkedInGarage> lsVehicle = new List <ICanBeParkedInGarage>();
MenuInputResult result = MenuInputResult.NA;
this.Ui.Clear();
// Skriv ut menyn
this.Ui.WriteLine(this.MenuFactory.GetMenu(MenuType.SEARCH_VEHICLE_WITH_TEXT));
// Läs in data från användaren
string strInput = this.Ui.ReadLine();
if (!String.IsNullOrWhiteSpace(strInput))
{
strInput = strInput.Trim();
if (strInput.Length == 1 && strInput.StartsWith('0'))
{// Användaren har valt att avsluta programmet. Återgå till menyn
result = MenuInputResult.TO_GARAGE_MENU;
return(result);
}
else
{
strInput = strInput.ToLower();
string[] strArray = strInput.Split(' ', StringSplitOptions.RemoveEmptyEntries);
int iNumber = 0;
if (strArray.Length > 0)
{
// Hämta vald garagehandler
IGarageHandler garageHandler = this.GarageHandlers.FirstOrDefault(g => g.GuidId.Equals(this.SelectedGarageHandlerGuid));
if (garageHandler != null)
{
foreach (string str in strArray)
{
if (!String.IsNullOrWhiteSpace(str))
{// Vi har tecken. Gör en sökning
// Sök på registreringsnummer
var tmpVehiclesRegistrationNumber = garageHandler.Garage.Where(v => ((IVehicle)v).RegistrationNumber.Equals(str, StringComparison.OrdinalIgnoreCase)).ToList();
if (tmpVehiclesRegistrationNumber?.Count > 0)
{
lsVehicle.AddRange(tmpVehiclesRegistrationNumber);
lsMatchedRegistrationnumbers.Add(str);
}
// Sök på färg
var tmpVehiclesColor = garageHandler.Garage.Where(v => ((IVehicle)v).Color.Equals(str, StringComparison.OrdinalIgnoreCase)).ToList();
if (tmpVehiclesColor?.Count > 0)
{
lsVehicle.AddRange(tmpVehiclesColor);
lsMatchedColors.Add(str);
}
// Sök på fordonstyp
var tmpVehiclesType = garageHandler.Garage.Where(v => v.GetType().Name.Equals(str, StringComparison.OrdinalIgnoreCase)).ToList();
if (tmpVehiclesType?.Count > 0)
{
lsVehicle.AddRange(tmpVehiclesType);
lsMatchedTypes.Add(str);
}
if (Int32.TryParse(str, out iNumber))
{
// Sök på antalet hjul
var tmpVehiclesNumberOfWheels = garageHandler.Garage.Where(v => ((WheeledVehicle)v).NumberOfWheels == iNumber).ToList();
if (tmpVehiclesNumberOfWheels?.Count > 0)
{
lsVehicle.AddRange(tmpVehiclesNumberOfWheels);
lsMatchedNumberOfWheels.Add(iNumber);
}
// Sök på antalet sittande passagerare
var tmpVehiclesNumberOfSeatedPassengers = garageHandler.Garage.Where(v => ((WheeledVehicle)v).NumberOfSeatedPassengers == iNumber).ToList();
if (tmpVehiclesNumberOfSeatedPassengers?.Count > 0)
{
lsVehicle.AddRange(tmpVehiclesNumberOfSeatedPassengers);
lsMatchedNumberOfSeatedPassengers.Add(iNumber);
}
}
}
}// End of foreach strArray
// Nu skall vi filtrera listan med fordon som har matchat något i sökningen
if (lsVehicle?.Count > 0)
{
// Nu vill jag filtrera resultatet med de ord i texten som vi har fått matchningar
lsVehicle = FilterSearchResult(lsVehicle, lsMatchedRegistrationnumbers, lsMatchedColors, lsMatchedTypes, lsMatchedNumberOfWheels, lsMatchedNumberOfSeatedPassengers);
// Se till att alla dubbletter försvinner
lsVehicle = lsVehicle.Distinct().ToList();
if (lsVehicle?.Count > 0)
{
// Skriv ut de fordon som sökningen matchar
foreach (IVehicle vehicle in lsVehicle)
{
Ui.WriteLine(vehicle.ToString());
}
}
else
{
Ui.WriteLine($"Hittade inga fordon med sökningen {strInput}");
}
}
else
{
Ui.WriteLine($"Hittade inga fordon med sökningen {strInput}");
}
Ui.WriteLine("Return för att fortsätta");
Ui.ReadLine();
}
}
else
{
result = MenuInputResult.WRONG_INPUT;
}
}
}
else
{
result = MenuInputResult.WRONG_INPUT;
}
return(result);
}
/// <summary>
/// Metoden hanterar inmatning av kommandon från ui
/// </summary>
/// <returns>enum MenuInputResult med olika värden beroende på användarens kommando</returns>
private MenuInputResult HandleInput()
{
int iSelectedGarage = 0;
MenuInputResult result = MenuInputResult.NA;
string strInput = this.Ui.ReadLine();
if (!String.IsNullOrWhiteSpace(strInput))
{
strInput = strInput.Trim();
if (strInput.StartsWith('0'))
{// Användaren har valt att avsluta programmet
result = MenuInputResult.EXIT;
}
else if (strInput.StartsWith('1'))
{// Skapa garage
CreateGarageMenu createGarageMenu = new CreateGarageMenu(this.MenuFactory, this.Ui, this.GarageHandlers);
result = createGarageMenu.Show();
}
else if (strInput.StartsWith('2'))
{// Gå till ett Garage
// Låt användaren välja gararge
SelectGarageMenu selectGarageMenu = new SelectGarageMenu(this.MenuFactory, this.Ui, this.GarageHandlers);
iSelectedGarage = selectGarageMenu.Show();
// Låt användaren interagera med garaget
if (iSelectedGarage > 0)
{// Användaren har valt ett garage
GarageMenu garageMenu = new GarageMenu(this.MenuFactory, this.Ui, this.GarageHandlers, this.GarageHandlers[iSelectedGarage - 1].GuidId, this.RegistrationNumberRegister);
result = garageMenu.Show();
}
}
else if (strInput.StartsWith('3'))
{// Radera ett garage
// Låt användaren välja garage
DeleteGarageMenu deleteGarageMenu = new DeleteGarageMenu(this.MenuFactory, this.Ui, this.GarageHandlers);
iSelectedGarage = deleteGarageMenu.Show();
if (iSelectedGarage > 0)
{
try
{
this.GarageHandlers.RemoveAt(iSelectedGarage - 1);
}
catch (Exception)
{
Ui.WriteLine("Exception. MainMenu.HandleInput(). Borttagning av garage fungerade inte");
}
}
}
else
{
result = MenuInputResult.WRONG_INPUT;
}
}
else
{
result = MenuInputResult.WRONG_INPUT;
}
return(result);
}
/// <summary>
/// Metoden läser in registreringsnumret från användaren
/// Användaren kan också välja att automatisk skapa ett registreringsnummer
/// </summary>
/// <returns>MenuInputResult och registreringsnumret</returns>
private (MenuInputResult menuInputResult, string strRegistrationNumber) GetRegistrationNumber()
{
MenuInputResult result = MenuInputResult.NA;
string strRegistrationNumber = String.Empty;
string strInput = String.Empty;
bool bRun = true;
do
{
this.Ui.Clear();
if (result == MenuInputResult.WRONG_INPUT)
{
this.Ui.WriteLine("Felaktig inmatning");
}
if (result == MenuInputResult.REGISTRATIONNUMBER_EXISTS)
{
this.Ui.WriteLine("Registreringsnumret finns redan");
}
result = MenuInputResult.NA;
// Visa menyn
this.Ui.WriteLine(this.MenuFactory.GetMenu(MenuType.CREATE_REGISTRATIONNUMBER));
// Inläsning av fordonets registreringsnummer från användaren
strInput = this.Ui.ReadLine();
if (!String.IsNullOrWhiteSpace(strInput))
{
strInput = strInput.Trim();
if (strInput.Length == 1 && strInput.StartsWith('0'))
{// Användaren har valt att avsluta programmet. Återgå till menyn
result = MenuInputResult.TO_GARAGE_MENU;
return(result, strRegistrationNumber);
}
else if (strInput.Length == 1 && strInput.StartsWith('1'))
{// Användaren har valt att skapa ett registreringsnummer
strRegistrationNumber = this.RegistrationNumberRegister.CreateRandomRegistrationNumber();
result = MenuInputResult.CONTINUE;
return(result, strRegistrationNumber);
}
strRegistrationNumber = strInput.ToUpper();
if (this.RegistrationNumberRegister.CheckIfRegistrationNumberExists(strRegistrationNumber))
{
result = MenuInputResult.REGISTRATIONNUMBER_EXISTS;
}
else
{
bRun = false;
result = MenuInputResult.CONTINUE;
}
}
else
{
bRun = false;
result = MenuInputResult.TO_GARAGE_MENU;
}
} while (bRun);
return(result, strRegistrationNumber);
}
/// <summary>
/// Metoden skapar ett nytt fordon av typ car, bus eller motocycle
/// </summary>
/// <param name="enumVehicleType">Enum som bestämmer vilket fordon vi skall skapa</param>
/// <returns>MenuInputResult och ny vehicle. Vehicle kan vara null. Då gick det inte skapa fordonet eller har användaren valt att återgå till menyn</returns>
private (MenuInputResult menuInputResult, ICanBeParkedInGarage newVehicle) CreateVehicle(Vehicle_Type enumVehicleType)
{
MenuInputResult result = MenuInputResult.NA;
ICanBeParkedInGarage newVehicle = null;
IVehicleFactory vehicleFactory = new VehicleFactory(this.RegistrationNumberRegister);
string strRegistrationNumber = String.Empty;
string strColor = String.Empty;
int iNumberOfWheels = 0;
int iNumberOfSeatedPassengers = 0;
// Hämta defaulta värden för fordonet som vi skall skapa
var(strDefaultColor, iDefaultNumberOfWheels, iDefaultNumberOfSeatedPassengers) = vehicleFactory.GetDefaultVehicleData(enumVehicleType);
// Hämta registreringsnumret från användaren
var(tmpResult, strTmpRegistrationNumber) = GetRegistrationNumber();
result = tmpResult;
if (tmpResult == MenuInputResult.CONTINUE)
{// Vi fortsätter och hämtar fordonets färg
strRegistrationNumber = strTmpRegistrationNumber;
// Hämta fordonets färg från användaren
var(tmpResult1, strTmpColor) = GetColor(strDefaultColor);
result = tmpResult1;
if (tmpResult1 == MenuInputResult.CONTINUE)
{
strColor = strTmpColor;
// Hämta antal hjul som finns på fordonet
var(tmpResult2, iTmpNumberOfWheels) = GetNumberOfWheels(iDefaultNumberOfWheels);
result = tmpResult2;
if (tmpResult2 == MenuInputResult.CONTINUE)
{
iNumberOfWheels = iTmpNumberOfWheels;
// Hämta antal sittande passagerare
var(tmpResult3, iTmpNumberOfSeatedPassengers) = GetNumberOfSeatedPassengers(iDefaultNumberOfSeatedPassengers);
result = tmpResult3;
if (tmpResult3 == MenuInputResult.CONTINUE)
{
iNumberOfSeatedPassengers = iTmpNumberOfSeatedPassengers;
newVehicle = vehicleFactory.CreateVehicle(enumVehicleType, strRegistrationNumber, strColor, iNumberOfWheels, iNumberOfSeatedPassengers);
if (newVehicle != null)
{
result = MenuInputResult.CREATE_VEHICLE_FAILED;
}
else
{
result = MenuInputResult.TO_GARAGE_MENU;
}
}
}
}
}
return(result, newVehicle);
}
/// <summary>
/// Metoden läser in antalet hjul som fodonet har. Användaren kan också välja default antal hjul
/// </summary>
/// <param name="iDefaultNumberOfWheels">Default antal hjul</param>
/// <returns>MenuInputResult och antal hjul som fordonet har</returns>
private (MenuInputResult menuInputResult, int iNumberOfWheels) GetNumberOfWheels(int iDefaultNumberOfWheels)
{
MenuInputResult result = MenuInputResult.NA;
string strInput = string.Empty;
string strNumberOfWheelsMenu = String.Empty;
int iNumberOfWheels = 0;
bool bRun = true;
do
{
this.Ui.Clear();
if (result == MenuInputResult.WRONG_INPUT)
{
this.Ui.WriteLine("Felaktig inmatning");
}
result = MenuInputResult.NA;
// Visa menyn. Lite special för att kunna få med default antal hjul
strNumberOfWheelsMenu = this.MenuFactory.GetMenu(MenuType.CREATE_NUMBER_OF_WHEELS);
strNumberOfWheelsMenu = strNumberOfWheelsMenu + ". (Default är " + iDefaultNumberOfWheels + ")" + System.Environment.NewLine;
this.Ui.WriteLine(strNumberOfWheelsMenu);
// Inläsning av antalet hjul
strInput = this.Ui.ReadLine();
if (!String.IsNullOrWhiteSpace(strInput))
{
strInput = strInput.Trim();
if (strInput.Length == 1 && strInput.StartsWith('0'))
{// Användaren har valt att avsluta programmet. Återgå till menyn
result = MenuInputResult.TO_GARAGE_MENU;
return(result, iNumberOfWheels);
}
else if (strInput.Length == 1 && strInput.StartsWith('1'))
{// Användaren har valt defaulta antalet hjul på fordonet
iNumberOfWheels = iDefaultNumberOfWheels;
result = MenuInputResult.CONTINUE;
return(result, iNumberOfWheels);
}
// Försök att konvertera input till en siffra
if (int.TryParse(strInput, out iNumberOfWheels) && iNumberOfWheels > 0)
{
result = MenuInputResult.CONTINUE;
bRun = false;
}
else
{// Det var ingen siffra
result = MenuInputResult.WRONG_INPUT;
}
}
else
{
bRun = false;
result = MenuInputResult.TO_GARAGE_MENU;
}
} while (bRun);
return(result, iNumberOfWheels);
}
