private void setEnergyInVehicle(Vehicle i_Vehicle)
{
float currentPercentOfEnergy;
Console.WriteLine("insert current percent energy in your vehicle");
bool clientInsertLegalPercent = false;
while (!clientInsertLegalPercent)
{
if (float.TryParse(Console.ReadLine(), out currentPercentOfEnergy))
{
try
{
VehicleCreator.VehicleEnergyProperty(i_Vehicle, currentPercentOfEnergy);
clientInsertLegalPercent = true;
}
catch (ValueOutOfRangeException voore)
{
Console.WriteLine("insert percent between 0 to 100");
}
}
else
{
Console.WriteLine("it ilegal input try again");
}
}
}
private Vehicle chooseVehicleType(string i_LicenseNumber)
{
// The next printing section was done with Enum.GetName because of note number 4 in the document exercise.
// In this way, the system can add new vehicles with adding the new vehicle class and editing the "CreateVehicle.cs" code only.
Vehicle newVehicle = null;
Console.WriteLine("Select vehicle type:");
string[] supportedVehicleTypes = Enum.GetNames(typeof(VehicleCreator.eSupportedVehicles));
for (int i = 1; i <= supportedVehicleTypes.Length; i++)
{
Console.WriteLine("{0}. {1}", i, supportedVehicleTypes[i - 1]);
}
int vehicleTypeChoice;
bool isValidSelection = false;
while (isValidSelection == false)
{
vehicleTypeChoice = readIntFromConsole();
try
{
newVehicle = VehicleCreator.MakeVehicle(vehicleTypeChoice, i_LicenseNumber);
isValidSelection = true;
}
catch (ArgumentException)
{
UIMessages.DisplayMessages(UIMessages.eGeneralMessages.InvalidSelection);
}
}
return(newVehicle);
}
private static void Main(string[] args)
{
Console.WriteLine("Hello World!");
var carBuilder = new CarBuilder();
var car = new VehicleCreator(carBuilder);
car.CreateVehicleCaracteristics();
Console.WriteLine(carBuilder.ToString());
car.CreateVehicleAcessories();
Console.WriteLine(carBuilder.ToString());
//alternativa
var truckBuilder = new TruckBuilder()
.SetModel("FH-420")
.SetColor("Black")
.SetYear(2020);
Console.WriteLine(truckBuilder.ToString());
truckBuilder.SetAcessories(new List <string> {
"Geladeira", "Capa para bancos", "Alarme"
});
Console.WriteLine(truckBuilder.ToString());
Console.ReadKey();
}
public static void GarageManagingProgram()
{
Garage myGarage = new Garage();
bool programContinue = true;
VehicleCreator.InitializeVehicleTypeList();
PrintGarageIntro();
while (programContinue)
{
PrintGarageMenu();
try
{
ManageUserChoiseOfAction(myGarage, Console.ReadLine(), ref programContinue);
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
System.Threading.Thread.Sleep(1000);
}
ExitSequence();
}
private void insertNewVehicle(string i_LicenseNumber)
{
eVehicleType userVehicleTypeChoice;
Vehicle vehicleToCreate;
string vehicleModelName;
string wheelManufacturerName;
string ownerName;
string ownerPhoneNumber;
System.Console.WriteLine("{0}--Vehicle Details--", Environment.NewLine);
System.Console.WriteLine("{0}Enter vehicle model name:", Environment.NewLine);
vehicleModelName = System.Console.ReadLine();
userVehicleTypeChoice = getUserRequestToVehicleTypeChoice();
vehicleToCreate = VehicleCreator.CreateVehicle(userVehicleTypeChoice, vehicleModelName, i_LicenseNumber);
setUserVehicleProperties(vehicleToCreate);
System.Console.WriteLine("{0}Enter Owner name:", Environment.NewLine);
ownerName = System.Console.ReadLine();
System.Console.WriteLine("{0}Enter Owner phone number name:", Environment.NewLine);
ownerPhoneNumber = System.Console.ReadLine();
System.Console.WriteLine("{0}Enter wheel manufacturer name:", Environment.NewLine);
wheelManufacturerName = System.Console.ReadLine();
vehicleToCreate.SetAllWheels(wheelManufacturerName);
r_GarageManagement.AddVehicle(ownerName, ownerPhoneNumber, vehicleToCreate);
System.Console.WriteLine("{0}Vehicle added successfully!", Environment.NewLine);
}
private bool connetToMongoDB(string i_ServerAddress, string i_Username, string i_Password)
{
// garage.edik2.mongodb.net
bool isConnected = true;
StringBuilder connectionString = new StringBuilder();
connectionString.Append(@"mongodb+srv://");
connectionString.Append(i_Username);
connectionString.Append(':');
connectionString.Append(i_Password);
connectionString.Append('@');
connectionString.Append(i_ServerAddress);
try
{
var client = new MongoClient(connectionString.ToString());
client.ListDatabaseNames();
var DB = client.GetDatabase("Garage");
m_Collection = DB.GetCollection <BsonDocument>("Vehicles");
}
catch (Exception)
{
isConnected = false;
MessageBox.Show("There was an error connection to MongoDB\r\nPlease check the server address, username and password.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
VehicleCreator.RegisterVehicles();
return(isConnected);
}
private void wheelsProperty(Vehicle i_Vehicle)
{
bool clientInsertLegalPresser = false;
string manufacturerNameOfWheels;
float airPressure = 0;
Console.WriteLine("insert name of manufacturer of wheels");
manufacturerNameOfWheels = Console.ReadLine();
Console.WriteLine("insert air pressure that you want in wheels");
while (!clientInsertLegalPresser)
{
if (float.TryParse(Console.ReadLine(), out airPressure))
{
try
{
VehicleCreator.VehicleWheelsProperty(i_Vehicle, manufacturerNameOfWheels, airPressure);
clientInsertLegalPresser = true;
}
catch (ValueOutOfRangeException voore)
{
Console.WriteLine(voore.Message);
}
}
else
{
Console.WriteLine("it ilegal input try again");
}
}
}
private bool isValidType()
{
bool isValid = true;
try
{
VehicleCreator.FromStringToVehicleTypeEnum(ComboBoxVehicleType.Text);
}
catch (GarageLogic.ValueOutOfRangeException ec)
{
isValid = false;
string message = ec.Message;
string title = "Invalid Input";
MessageBox.Show(message, title);
}
catch (FormatException ec)
{
isValid = false;
string message = ec.Message;
string title = "Invalid Input";
MessageBox.Show(message, title);
}
if (isValid == false)
{
ComboBoxVehicleType.SelectedIndex = -1;
}
return(isValid);
}
static void Main(string[] args)
{
VehicleCreator vehicleCreator = new VehicleCreator(new TataHexaVehicle("2019"));
vehicleCreator.CreateVehicle();
vehicleCreator.GetVehicle().DisplayDetails();
Console.ReadLine();
}
public static void AddGarageSlotToTheGarage(Garage io_MyGarage, string i_VehicleLicenseNumber)
{
bool enterLoop = true;
int counterIndicator = 1;
string typeOfVehicle = null;
GarageSlot newGarageSlot = null;
Vehicle newVehicle = null;
if (io_MyGarage.M_MyGarage.TryGetValue(i_VehicleLicenseNumber, out newGarageSlot) == false)
{
Console.WriteLine("Choose one of the following vehicles by number:");
foreach (VehicleCreator.eVehicles currentType in VehicleCreator.m_VehicleTypes)
{
Console.WriteLine(string.Format("{0}.{1}", counterIndicator, currentType.ToString()));
counterIndicator += 1;
}
while (enterLoop == true)
{
try
{
typeOfVehicle = Console.ReadLine();
newVehicle = VehicleCreator.CreateVehicle(VehicleCreator.ToEVehicle(typeOfVehicle), i_VehicleLicenseNumber);
enterLoop = false;
}
catch (Exception exception)
{
System.Console.WriteLine(exception.Message);
}
}
enterLoop = true;
while (enterLoop)
{
try
{
CreateNewGarageSlot(out newGarageSlot, newVehicle);
enterLoop = false;
}
catch (FormatException exception)
{
System.Console.WriteLine(exception.Message);
}
}
RecieveAdditionalVehicleInformation(newGarageSlot, typeOfVehicle);
io_MyGarage.M_MyGarage.Add(newVehicle.M_LicenseNumber, newGarageSlot);
}
else
{
newGarageSlot.UpdateVehicleStatus(GarageSlot.eGarageStatus.BeingFixed);
throw new ArgumentException("The vehicle is already in the garage! It's status was updated to Being Fixed.");
}
}
void Start()
{
if (GameObject.Find("CarStays"))
{
car_stay_ob = GameObject.Find("CarStays").transform;
}
patch_sc = GameObject.Find("Game").GetComponent <Patches>();
vehicle_creator_sc = GameObject.Find("Game").GetComponent <VehicleCreator>();
Invoke("FindPoint", important * 0.01f);
}//Start
public VehicleServiceTest()
{
//Intializing my Mapper
var domainToEntityProfile = new DomainToEntityProfile();
var configuration = new MapperConfiguration(cfg => cfg.AddProfile(domainToEntityProfile));
var _mapper = new Mapper(configuration);
_dataservice = new VehicleFakeDataService();
_service = new VehicleCreator(_dataservice, _mapper);
}
static void Main(string[] args)
{
var vehicleCreator = new VehicleCreator();
for (int i = 1; i <= 4; i++)
{
var vehicle = vehicleCreator.GetVehicle(i);
vehicle.Accelerate();
vehicle.Stop();
}
}
public AddVehicleForm(GarageManager i_GarageManagerReference)
{
m_VehicleDetailesFilled = false;
r_GarageManagerReference = i_GarageManagerReference;
InitializeComponent();
foreach (string vehicleType in VehicleCreator.GetListOfVehicleTypes())
{
VehicleTypeComboBox.Items.Add(vehicleType);
}
}
public static void EnterNewVehicleToGarage(Garage i_Garage, string i_LicenseNumber)
{
Vehicle vehicle = CreateNewVehicle(i_LicenseNumber);
string ownerName = GetOwnerName();
string ownerPhone = GetOwnerPhone();
VehicleInformation newVehicleInGarage = VehicleCreator.CreateVehicleWithFullInformation(vehicle, ownerName, ownerPhone);
i_Garage.AddToGarage(newVehicleInGarage);
}
public void GetVehicle_Returns_Null()
{
Mock <IVehicleBuilder> _mockVehicleBuilder = new Mock <IVehicleBuilder>();
_mockVehicleBuilder.Setup(m => m.GetVehicle()).Returns((Vehicle)null);
VehicleCreator vehicleCreator = new VehicleCreator(_mockVehicleBuilder.Object);
Vehicle vehicle = vehicleCreator.GetVehicle();
Assert.IsNull(vehicle);
}
private Vehicle vehicleInput(string i_LicensePlate)
{
VehicleCreator.eVehicleType vehicleType;
string vehicleModelName, wheelsProducerName;
float currentWheelsAirPressure;
Vehicle vehicleToReturn = null;
bool isInvalidVehicle = true;
vehicleType = printMenuFormatAndReturnUserChoice <VehicleCreator.eVehicleType>("Choose vehicle type:");
Console.WriteLine("Enter vehicle model name:");
vehicleModelName = Console.ReadLine();
checkBackToMainMenu(vehicleModelName);
Console.WriteLine("Enter wheels producer name:");
wheelsProducerName = Console.ReadLine();
checkBackToMainMenu(wheelsProducerName);
while (isInvalidVehicle)
{
try
{
currentWheelsAirPressure = garagePositiveFloatVaribalesInput("Enter wheels current air pressure:");
// create the vehicle:
vehicleToReturn = VehicleCreator.CreateVehicle(vehicleType, vehicleModelName, i_LicensePlate, currentWheelsAirPressure, wheelsProducerName);
if (vehicleToReturn.Engine is GasEngine)
{
vehicleToReturn.Engine.CurrentEnergyQuantity = garagePositiveFloatVaribalesInput("Enter current fuel litters in the tank:");
}
else // electric engine
{
vehicleToReturn.Engine.CurrentEnergyQuantity = garagePositiveFloatVaribalesInput("Enter current battery charge in minutes:") / 60;
}
isInvalidVehicle = false;
}
catch (FormatException formatException)
{
Console.WriteLine(formatException.Message);
}
catch (ArgumentException argumentException)
{
Console.WriteLine(argumentException.Message);
}
catch (ValueOutOfRangeException outOfRangeException)
{
Console.WriteLine(string.Format("{0} (Range: {1} - {2})", outOfRangeException.Message, outOfRangeException.MinValue, outOfRangeException.MaxValue));
}
}
return(vehicleToReturn);
}
private Vehicle creatNewVehicle()
{
int i = 1;
int vehicleTypeNum;
int engineTypeNum;
string vehicleTypeStr;
string isElectricVehicleStr;
bool isElectricVehicle = false;
Vehicle newVehicle;
Console.Clear();
Console.WriteLine("Please enter the vehicle type:");
foreach (string vehicleType in Enum.GetNames(typeof(VehicleCreator.eTypeOfVehicle)))
{
Console.WriteLine(string.Format("{0}) {1}", i, vehicleType));
i++;
}
vehicleTypeStr = Console.ReadLine();
if (!int.TryParse(vehicleTypeStr, out vehicleTypeNum))
{
throw new FormatException(k_ExceptionNotNumber);
}
else if (!Enum.IsDefined(typeof(VehicleCreator.eTypeOfVehicle), vehicleTypeNum))
{
throw new ValueOutOfRangeException(1, Enum.GetNames(typeof(VehicleCreator.eTypeOfVehicle)).Length);
}
Console.WriteLine("Is the Vehcile Electric? (1- yes, 2- no)");
isElectricVehicleStr = Console.ReadLine();
if (!int.TryParse(isElectricVehicleStr, out engineTypeNum))
{
throw new FormatException(k_ExceptionNotNumber);
}
if (engineTypeNum > 2 && engineTypeNum < 1)
{
throw new ValueOutOfRangeException(1, 2);
}
if (engineTypeNum == 1)
{
isElectricVehicle = true;
}
newVehicle = VehicleCreator.CreateNewVehicle((VehicleCreator.eTypeOfVehicle)vehicleTypeNum, isElectricVehicle);
return(newVehicle);
}
private void carPropertise(Vehicle i_Car)
{
Console.WriteLine("Insert plase number of doors between 2 - 5 and then press 'enter' (defualt is 2)");
if (!byte.TryParse(Console.ReadLine(), out byte numOfDoors) || !(numOfDoors >= 2 && numOfDoors <= 5))
{
numOfDoors = 2;
}
Console.WriteLine("Now insert your car color");
Console.WriteLine("Insert your number of choice then press 'enter'");
Console.WriteLine(EnumChoises(typeof(Car.eCarColor)));
getEnumChoise(typeof(Car.eCarColor), out Car.eCarColor chosenColor);
VehicleCreator.CarPropertise(i_Car, numOfDoors, chosenColor);
}
public void TestMethod1()
{
var build = new HeroBuilder();
var value = new VehicleCreator(build);
value.CreateVehicle();
var a = value.GetVehicle();
Assert.AreEqual("Hero", a.Model);
Assert.AreEqual("4 Stroke", a.Engine);
Assert.AreEqual("Plastic", a.Body);
Assert.AreEqual("120 km/hr", a.Transmission);
Assert.AreEqual("Seat Cover", a.Accessories[0]);
Assert.AreEqual("Rear Mirror", a.Accessories[1]);
}
public void HeroGetVehicle_ShouldReturn_HeroProperties()
{
var build = new HeroBuilder();
var value = new VehicleCreator(build);
value.CreateVehicle();
var a = value.GetVehicle();
Assert.Equal("Hero", a.Model);
Assert.Equal("4 Stroke", a.Engine);
Assert.Equal("Plastic", a.Body);
Assert.Equal("120 km/hr", a.Transmission);
Assert.Equal("Seat Cover", a.Accessories[0]);
Assert.Equal("Rear Mirror", a.Accessories[1]);
}
public void GetVehicle_Returns_Camaro()
{
Vehicle camaro = new Vehicle()
{
Make = "Chevrolet", Model = "Camaro", Body = "Coupe", Engine = "8 Cylinder", Transmission = "Manual"
};
Mock <IVehicleBuilder> _mockVehicleBuilder = new Mock <IVehicleBuilder>();
_mockVehicleBuilder.Setup(m => m.GetVehicle()).Returns(camaro);
VehicleCreator vehicleCreator = new VehicleCreator(_mockVehicleBuilder.Object);
Vehicle vehicle = vehicleCreator.GetVehicle();
Assert.AreEqual <string>("Camaro", vehicle.Model);
}
public void Test2()
{
var build = new HondaBuilder();
var value = new VehicleCreator(build);
value.CreateVehicle();
var a = value.GetVehicle();
Assert.Equal("Honda", a.Model);
Assert.Equal("4 Stroke", a.Engine);
Assert.Equal("Plastic", a.Body);
Assert.Equal("125 km/hr", a.Transmission);
Assert.Equal("Seat Cover", a.Accessories[0]);
Assert.Equal("Rear Mirror", a.Accessories[1]);
Assert.Equal("Helmet", a.Accessories[2]);
}
private void ButtonShowDetailes_Click(object sender, EventArgs e)
{
removeDynamicControls();
if (LicensePlateNumberTextBox.Text == string.Empty)
{
MessageBox.Show("Enter license plate number", "ERROR", MessageBoxButtons.OK);
}
else
{
Vehicle vehicleToPrint;
List <string> vehicleDetailes;
if (!r_GarageManager.IsConnectedToDB)
{
r_GarageManager.VehiclesDictionary.TryGetValue(LicensePlateNumberTextBox.Text.GetHashCode(), out vehicleToPrint);
}
else
{
var filter = Builders <BsonDocument> .Filter.Eq("_id", LicensePlateNumberTextBox.Text);
BsonDocument bsonVehicle = r_GarageManager.DBCollection.Find(filter).FirstOrDefault();
vehicleToPrint = VehicleCreator.ConvertBsonDocumentToVehicle(bsonVehicle);
}
if (vehicleToPrint == null)
{
MessageBox.Show("Vehicle with license palate number " + LicensePlateNumberTextBox.Text + " not exist", "ERROR", MessageBoxButtons.OK);
}
else
{
int lastParameterBottom = LicensePlateNumberLabel.Bottom;
vehicleDetailes = vehicleToPrint.GetVehicleFullDetailes();
foreach (string vehicleParameter in vehicleDetailes)
{
Label parameter = new Label();
parameter.AutoSize = true;
parameter.Text = vehicleParameter;
parameter.Left = LicensePlateNumberLabel.Left;
parameter.Top = lastParameterBottom + 10;
Controls.Add(parameter);
lastParameterBottom = parameter.Bottom;
}
ButtonCancel.Top = lastParameterBottom + 10;
this.Height = ButtonCancel.Bottom + 50;
}
}
}
private void motorcyclePropertise(Vehicle i_Moto)
{
const int maxEngieCapacity = 7_000;
Console.WriteLine(
"Insert plase Engine Capacity between 0 - {0} and then press 'enter' (defualt is 500)"
, maxEngieCapacity);
if (!int.TryParse(Console.ReadLine(), out int engineCapacity) || !(engineCapacity >= 0 && engineCapacity <= maxEngieCapacity))
{
engineCapacity = 500;
}
Console.WriteLine("Choose type of license");
Console.WriteLine(EnumChoises(typeof(Motorcycle.eTypeOfLicense)));
getEnumChoise(typeof(Motorcycle.eTypeOfLicense), out Motorcycle.eTypeOfLicense typeOfLicense);
VehicleCreator.MotorcyclePropertise(i_Moto, engineCapacity, typeOfLicense);
}
private static void Builder()
{
var vehicleCreator = new VehicleCreator(new BMWBuilder());
vehicleCreator.CreateVehicle();
var vehicle = vehicleCreator.GetVehicle();
vehicle.ShowInfo();
Console.WriteLine("---------------------------------------------");
vehicleCreator = new VehicleCreator(new HondaBuilder());
vehicleCreator.CreateVehicle();
vehicle = vehicleCreator.GetVehicle();
vehicle.ShowInfo();
Console.ReadKey();
}
static void Main(string[] args)
{
var vehicleCreator = new VehicleCreator(new HeroBuilder());
vehicleCreator.CreateVehicle();
var vehicle = vehicleCreator.GetVehicle();
vehicle.ShowInfo();
Console.WriteLine("---------------------------------------------");
vehicleCreator = new VehicleCreator(new HondaBuilder());
vehicleCreator.CreateVehicle();
vehicle = vehicleCreator.GetVehicle();
vehicle.ShowInfo();
Console.ReadKey();
}
private void trackPropertise(Vehicle i_Track)
{
const float maxTrunkCapacity = 7_000;
Console.WriteLine("Insert plase Trunk Capacity between 0 - 600,000 and then press 'enter' (defualt is 100,000)");
if (!float.TryParse(Console.ReadLine(), out float trunkCapacity) || !(trunkCapacity >= 0 && trunkCapacity <= maxTrunkCapacity))
{
trunkCapacity = 100_000f;
}
Console.WriteLine("insert true (any way) if you want Trunk With Cooling Cell, another for Trunk less Cooling Cell");
if (!bool.TryParse(Console.ReadLine(), out bool isHaveCoolTrunk))
{
isHaveCoolTrunk = false;
}
VehicleCreator.TrackPropertise(i_Track, trunkCapacity, isHaveCoolTrunk);
}
public static Vehicle CreateNewVehicle(string i_LicenseNumber)
{
int energyType = 1;
Dictionary <string, Type> dynamicParams = new Dictionary <string, Type>();
Dictionary <string, object> dynamicObject = new Dictionary <string, object>();
Console.WriteLine(@"Please Enter your type of vehicle");
int vehicleType = getEnumFromUser(typeof(VehicleCreator.eVehicleType));
if (vehicleType == 1 || vehicleType == 2)
{
Console.WriteLine(@"Please Enter your energy source:");
energyType = getEnumFromUser(typeof(VehicleCreator.ePowerType));
}
Console.WriteLine(@"Please Enter your model of vehicle");
string modelOfVehicle = Console.ReadLine();
float amountOfPowerSource = GetAmountOfPowerSource((VehicleCreator.eVehicleType)vehicleType,
(VehicleCreator.ePowerType)energyType);
PowerUsage power = VehicleCreator.CreatePowerSource(
(VehicleCreator.eVehicleType)vehicleType,
(VehicleCreator.ePowerType)energyType,
amountOfPowerSource);
Console.WriteLine("Please enter the manufacturer of the wheels");
string wheelsManufacturer = Console.ReadLine();
float currAirPressure = GetAirPressure((VehicleCreator.eVehicleType)vehicleType,
(VehicleCreator.ePowerType)energyType);
List <Wheel> vehicleWheels = VehicleCreator.CreateWheels(
(VehicleCreator.eVehicleType)vehicleType,
wheelsManufacturer,
currAirPressure);
VehicleCreator.GetRequiredVehicleParameters(vehicleType, dynamicParams);
getDynamicParametersDataFromUser(dynamicParams, dynamicObject);
Vehicle newVehicle = VehicleCreator.CreateVehicle((VehicleCreator.eVehicleType)vehicleType, modelOfVehicle, i_LicenseNumber, power, vehicleWheels, dynamicObject);
return(newVehicle);
}
public void BuilderTest()
{
// http://www.dotnettricks.com/learn/designpatterns/builder-design-pattern-dotnet
var vehicleCreator = new VehicleCreator(new HeroBuilder());
vehicleCreator.CreateVehicle();
var vehicle1 = vehicleCreator.GetVehicle();
vehicle1.ShowInfo();
Console.WriteLine("---------------------------------------------");
vehicleCreator = new VehicleCreator(new HondaBuilder());
vehicleCreator.CreateVehicle();
var vehicle2 = vehicleCreator.GetVehicle();
vehicle2.ShowInfo();
Assert.AreNotSame(vehicle1, vehicle2);
}
