public async Task <IActionResult> PutVehicleOwner(string id, VehicleOwner vehicleOwner)
{
if (id != vehicleOwner.ID)
{
return(BadRequest());
}
_context.Entry(vehicleOwner).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VehicleOwnerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public static VehicleOwner ToEntity(this VehicleOwnerViewModel model)
{
if (model == null)
{
return(null);
}
VehicleOwner entity = new VehicleOwner
{
Id = model.Id,
VehicleId = model.VehicleId,
BulgarianCitizenPin = model.BulgarianCitizenPin,
BulgarianCitizenFirstName = model.BulgarianCitizenFirstName,
BulgarianCitizenMiddleName = model.BulgarianCitizenMiddleName,
BulgarianCitizenLastName = model.BulgarianCitizenLastName,
ForeignCitizenPin = model.ForeignCitizenPin,
ForeignCitizenPn = model.ForeignCitizenPn,
ForeignCitizenNamesCyrillic = model.ForeignCitizenNamesCyrillic,
ForeignCitizenNamesLatin = model.ForeignCitizenNamesLatin,
ForeignCitizenNationality = model.ForeignCitizenNationality,
CompanyId = model.CompanyId,
CompanyName = model.CompanyName,
CompanyNameLatin = model.CompanyNameLatin,
};
return(entity);
}
public static VehicleOwnerViewModel ToViewModel(this VehicleOwner entity)
{
if (entity == null)
{
return(null);
}
VehicleOwnerViewModel model = new VehicleOwnerViewModel
{
Id = entity.Id,
VehicleId = entity.VehicleId,
BulgarianCitizenPin = entity.BulgarianCitizenPin,
BulgarianCitizenFirstName = entity.BulgarianCitizenFirstName,
BulgarianCitizenMiddleName = entity.BulgarianCitizenMiddleName,
BulgarianCitizenLastName = entity.BulgarianCitizenLastName,
ForeignCitizenPin = entity.ForeignCitizenPin,
ForeignCitizenPn = entity.ForeignCitizenPn,
ForeignCitizenNamesCyrillic = entity.ForeignCitizenNamesCyrillic,
ForeignCitizenNamesLatin = entity.ForeignCitizenNamesLatin,
ForeignCitizenNationality = entity.ForeignCitizenNationality,
CompanyId = entity.CompanyId,
CompanyName = entity.CompanyName,
CompanyNameLatin = entity.CompanyNameLatin,
};
return(model);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,ContactNumber,Email")] VehicleOwner vehicleOwner)
{
if (id != vehicleOwner.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(vehicleOwner);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VehicleOwnerExists(vehicleOwner.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(vehicleOwner));
}
private static void addNewVehicle(string i_LicencePlate)
{
eVehicles userVehicle;
string vehicleModel;
string ownerName;
string ownerPhoneNumber;
if (s_MyGarage.VehiclesStatusDictionary.ContainsKey(i_LicencePlate))
{
Console.WriteLine(MessagesEnglish.k_VehicleIsRegistered);
Console.WriteLine(MessagesEnglish.k_GoingBackToMainMenuMessage);
}
else
{
enterOwnerDetails(out ownerName, out ownerPhoneNumber);
VehicleOwner owner = new VehicleOwner(ownerName, ownerPhoneNumber);
userVehicle = (eVehicles)displayEnumOptions(typeof(eVehicles), MessagesEnglish.k_GetVehicleTypeMessage);
enterVehicleModel(out vehicleModel);
createVehicle(vehicleModel, i_LicencePlate, owner, userVehicle);
Console.WriteLine(MessagesEnglish.k_AddedNewCarMessage);
Console.WriteLine(MessagesEnglish.k_GoingBackToMainMenuMessage);
}
Thread.Sleep(3000);
Ex02.ConsoleUtils.Screen.Clear();
}
private static CarOwner ToOwner(this VehicleOwner owner)
{
return(owner.HasValue()
? new CarOwner {
Id = owner
}
: null);
}
public void WhenSetOwnership_ThenOwnedAndManaged()
{
var owner = new VehicleOwner("anownerid");
this.entity.SetOwnership(owner);
this.entity.Owner.Should().Be(new VehicleOwner(owner.OwnerId));
this.entity.Managers.Managers.Single().Should().Be("anownerid".ToIdentifier());
this.entity.Events[1].Should().BeOfType <Events.Car.OwnershipChanged>();
}
public async Task <IActionResult> Create([Bind("Id,Name,ContactNumber,Email")] VehicleOwner vehicleOwner)
{
if (ModelState.IsValid)
{
_context.Add(vehicleOwner);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(vehicleOwner));
}
private void storeNewVehicleInGarage()
{
VehicleOwner newOwnerToStore = new VehicleOwner();
Vehicle newVehicleToStore = null;
newOwnerToStore = createNewVehicleOwner();
newVehicleToStore = createNewVehicle();
changeVehicleDetails(ref newVehicleToStore);
m_CurrentGarage.StoreVehicle(newVehicleToStore, newOwnerToStore);
OutputManager.ShowMessage("Successfully entered to garage.");
pressToContinue();
}
private void AddNewOwner()
{
VehicleOwner owner = new VehicleOwner(Vehicle);
VehicleOwnerForm form = new VehicleOwnerForm(Database);
form.VehicleOwner = owner;
if (form.ShowDialog() == DialogResult.OK)
{
bsOwnerList.Add(owner);
MarkAsModified();
}
}
public async Task <uint> Handle(CreatePartnerCommand request, CancellationToken cancellationToken)
{
VehicleOwner owner = _Mapper.Map <CreatePartnerCommand, VehicleOwner> (request);
owner.DateAdded = DateTime.Now;
owner.DateUpdated = DateTime.Now;
_database.VehicleOwner.Add(owner);
await _database.SaveAsync();
return(owner.OwnerId);
}
private VehicleOwner getOwnerDetails()
{
string ownerName = string.Empty, ownerPhoneNumber = string.Empty;
Console.Clear();
ownerName = getOwnerValidData("Enter your name: ", false);
Console.Clear();
ownerPhoneNumber = getOwnerValidData("Enter your phone number: ", true);
VehicleOwner vehicleOwner = new VehicleOwner(ownerName, ownerPhoneNumber);
return(vehicleOwner);
}
private void EditCurrentOwner()
{
if (bsOwnerList.Current != null)
{
VehicleOwner owner = (VehicleOwner)bsOwnerList.Current;
VehicleOwner ownerCopy = new VehicleOwner(Vehicle, owner.Contractor, owner.DateFrom);
VehicleOwnerForm form = new VehicleOwnerForm(Database);
form.VehicleOwner = ownerCopy;
if (form.ShowDialog() == DialogResult.OK)
{
owner.Contractor = ownerCopy.Contractor;
owner.DateFrom = ownerCopy.DateFrom;
MarkAsModified();
}
}
}
public VehicleOwner AddReview(int ID, string Review, int Rate)
{
Service Service = ServiceBookContext.Service.FirstOrDefault(x => x.ID == ID);
if (Service.Review == null)
{
Service.Review = new Review();
Service.Review.Rate = Rate;
Service.Review.Service = Service;
}
Service.Review.Description += "\n" + Review;
ServiceBookContext.SaveChanges();
VehicleOwner VehicleOwner = Service.Vehicle.VehicleOwner;
return(VehicleOwner);
}
public async Task <ActionResult <VehicleOwner> > PostVehicleOwner(VehicleOwner vehicleOwner)
{
_context.vehicleOwners.Add(vehicleOwner);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (VehicleOwnerExists(vehicleOwner.ID))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtAction("GetVehicleOwner", new { id = vehicleOwner.ID }, vehicleOwner));
}
public bool UpdateOwner(VehicleOwner owner)
{
try
{
var model = GetOwner(owner.Id);
if (model == null)
{
_repository.Add(owner);
}
else
{
owner.ModifiedDate = DateTime.Now;
_repository.Update <VehicleOwner>(owner);
}
_unitOfWork.Commit();
}
catch (Exception ex)
{
return(false);
}
return(true);
}
private VehicleOwner createNewVehicleOwner()
{
VehicleOwner newVehicleOwner = new VehicleOwner();
bool isInputValid = false;
while (!isInputValid)
{
try
{
OutputManager.ShowMessage("Please enter the owner name:");
newVehicleOwner.Name = InputManager.GetUserInput().ToString();
OutputManager.ShowMessage("Please enter the owners phone number:");
newVehicleOwner.PhoneNumber = InputManager.GetUserInput().ToString();
isInputValid = true;
}
catch (ArgumentException ex)
{
OutputManager.ShowErrorMessage(string.Format("{0}", ex.Message));
pressToContinue();
}
}
return(newVehicleOwner);
}
public StoredVehicle(Vehicle i_VehicleToStore, VehicleOwner i_OwnerToStore)
{
m_Vehicle = i_VehicleToStore;
m_Owner = i_OwnerToStore;
m_VehicleState = eVehicleState.InRepair;
}
private static void createCar(bool i_IsElectric, string i_CarModel, string i_LicencePlate, VehicleOwner i_VehicleOwner, eVehicles vehicle)
{
float energyLeft;
eCarColors color;
eNumOfDoors numOfDoors;
float wheelsCurrentAirPressure;
string wheelMaker;
energyLeft = enterEnergyLeft(i_IsElectric, vehicle, i_IsElectric ? k_ElectricCarMaxBattery : k_CarMaxFuel);
color = (eCarColors)displayEnumOptions(typeof(eCarColors), MessagesEnglish.k_GetColorMessage);
numOfDoors = (eNumOfDoors)displayEnumOptions(typeof(eNumOfDoors), MessagesEnglish.k_GetNumDoorsMessage);
getWheelInformation(out wheelMaker, out wheelsCurrentAirPressure, s_MyGarage.CarMaxAirPressure);
if (i_IsElectric)
{
ElectricCar newElectricCar = CreateVehicle.CreateElectricCar(i_CarModel, i_LicencePlate, energyLeft, color,
numOfDoors, wheelMaker, wheelsCurrentAirPressure, i_VehicleOwner);
s_MyGarage.AddVehicleToGarage(newElectricCar);
}
else
{
Car newCar = CreateVehicle.CreateCar(i_CarModel, i_LicencePlate, energyLeft, color, numOfDoors, wheelMaker, wheelsCurrentAirPressure, i_VehicleOwner);
s_MyGarage.AddVehicleToGarage(newCar);
}
}
private static void createMotorcycle(bool i_IsElectric, string i_MotorcycleModel, string i_LicencePlate, VehicleOwner i_VehicleOwner, eVehicles i_Vehicle)
{
float energyLeft;
int validEngineVolume;
float wheelsCurrentAirPressure;
string wheelMaker;
eMotorcycleLicenceType licenceType;
energyLeft = enterEnergyLeft(i_IsElectric, i_Vehicle, i_IsElectric ? k_ElectricMotorcycleMaxBattery : k_MotorcycleMaxFuel);
licenceType = (eMotorcycleLicenceType)displayEnumOptions(typeof(eMotorcycleLicenceType), MessagesEnglish.k_GetLicenseTypeMessage);
validEngineVolume = enterEngineVolume();
getWheelInformation(out wheelMaker, out wheelsCurrentAirPressure, s_MyGarage.MotorcycleMaxAirPressure);
if (i_IsElectric)
{
ElectricMotorcycle newElectricMotorcycle = CreateVehicle.CreateElectricMotorcycle(i_MotorcycleModel, i_LicencePlate, energyLeft, licenceType,
validEngineVolume, wheelMaker, wheelsCurrentAirPressure, i_VehicleOwner);
s_MyGarage.AddVehicleToGarage(newElectricMotorcycle);
}
else
{
Motorcycle newMotorcycle = CreateVehicle.CreateMotorcycle(i_MotorcycleModel, i_LicencePlate, energyLeft, licenceType,
validEngineVolume, wheelMaker, wheelsCurrentAirPressure, i_VehicleOwner);
s_MyGarage.AddVehicleToGarage(newMotorcycle);
}
}
private static void createTruck(bool i_IsElectric, string i_TruckModel, string i_LicencePlate, VehicleOwner i_VehicleOwner, eVehicles i_Vehicle)
{
float fuelLeft;
float CargoVolume;
bool dangerousMaterials;
float wheelsCurrentAirPressure;
string wheelMaker;
fuelLeft = enterEnergyLeft(i_IsElectric, i_Vehicle, k_TruckMaxFuel);
dangerousMaterials = enterDangerousMaterialsInput();
CargoVolume = enterCargoVolume();
getWheelInformation(out wheelMaker, out wheelsCurrentAirPressure, s_MyGarage.TruckMaxAirPressure);
Truck newTruck = CreateVehicle.CreateTruck(i_TruckModel, i_LicencePlate, fuelLeft, dangerousMaterials, CargoVolume, wheelMaker, wheelsCurrentAirPressure, i_VehicleOwner);
s_MyGarage.AddVehicleToGarage(newTruck);
}
private static void createVehicle(string i_VehicleModel, string i_LicencePlate, VehicleOwner i_VehicleOwner, eVehicles i_Vehicle)
{
bool isElectricVehicle;
switch (i_Vehicle)
{
case eVehicles.Car:
isElectricVehicle = false;
createCar(isElectricVehicle, i_VehicleModel, i_LicencePlate, i_VehicleOwner, eVehicles.Car);
break;
case eVehicles.ElectricCar:
isElectricVehicle = true;
createCar(isElectricVehicle, i_VehicleModel, i_LicencePlate, i_VehicleOwner, eVehicles.ElectricCar);
break;
case eVehicles.Motorcycle:
isElectricVehicle = false;
createMotorcycle(isElectricVehicle, i_VehicleModel, i_LicencePlate, i_VehicleOwner, eVehicles.Motorcycle);
break;
case eVehicles.ElectricMotorcycle:
isElectricVehicle = true;
createMotorcycle(isElectricVehicle, i_VehicleModel, i_LicencePlate, i_VehicleOwner, eVehicles.ElectricMotorcycle);
break;
case eVehicles.Truck:
isElectricVehicle = false;
createTruck(isElectricVehicle, i_VehicleModel, i_LicencePlate, i_VehicleOwner, eVehicles.Truck);
break;
default:
Console.WriteLine(MessagesEnglish.k_InvalidInputMessage);
Console.WriteLine(MessagesEnglish.k_GoingBackToMainMenuMessage);
Thread.Sleep(2000);
break;
}
}
public void WhenConstructed_ThenOwnerIdAssigned()
{
var owner = new VehicleOwner("anownerid");
owner.OwnerId.Should().Be("anownerid");
}
public GarageVehicle(string i_OwnerName, string i_PhoneNumber, Vehicle i_VehicleInGarage)
{
m_Owner = new VehicleOwner(i_OwnerName, i_PhoneNumber);
m_FixState = GarageEnums.eFixState.BeingFixed;
m_VehicleInGarage = i_VehicleInGarage;
}
