public bool Leave(ParkedVehicle parkedVehicle)
{
OccupidePositions.Remove(parkedVehicle.Position);
NextFreeSpaces[parkedVehicle.Vehicle.VehicleTyp.SpacesNeeded] = null;
// parkedVehicle.Where = null;
parkedVehicle.Position = null;
var dickcount = NextFreeSpaces.Count;
Dictionary <int, Position> TempNextFreeSpaces = NextFreeSpaces.ToDictionary(k => k.Key, k => k.Value);
for (int i = 0; i < dickcount; i++)
{
var itemK = TempNextFreeSpaces.Keys.ElementAt(i);
var itemv = TempNextFreeSpaces[itemK];
if (itemv == null)
{
TempNextFreeSpaces[itemK] = GetNextSpot(new Position()
{
Z = 1,
X = 1,
Y = 1
}
, parkedVehicle.Vehicle.VehicleTyp.SpacesNeeded);
}
}
NextFreeSpaces = TempNextFreeSpaces;
return(true);
}
public async Task <IActionResult> Edit(int id, [Bind("ID,VehicleType,RegNum,Color,Make,Model,NumOfWheels,ArrivalTime")] ParkedVehicle parkedVehicle)
{
if (id != parkedVehicle.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(parkedVehicle);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ParkedVehicleExists(parkedVehicle.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Feedback), new { RegNum = parkedVehicle.RegNum, Message = "Has been updated" }));
}
return(View(parkedVehicle));
}
public async Task <IActionResult> Edit(int id, [Bind("ID,VehicleTypesID,MemberID,RegNum,Color,Make,Model")] ParkedVehicle parkedVehicle)
{
if (id != parkedVehicle.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(parkedVehicle);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ParkedVehicleExists(parkedVehicle.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["MemberID"] = new SelectList(_context.Set <Member>(), "Id", "ConfirmPassword", parkedVehicle.MemberID);
ViewData["VehicleTypeID"] = new SelectList(_context.Set <VehicleTypes>(), "ID", "VehicleTYpe", parkedVehicle.VehicleTypeID);
return(View(parkedVehicle));
}
// GET: Search by regnbr
public IActionResult Search(string Registreringsnummer)
{
IEnumerable <ParkedVehicle> parkedVehicleList = null; // = null;
ViewData["Title_Reg"] = "Registreringsnummer"; // Fält- och label-namn
ViewData["RegNbr"] = ""; // Ev. indata
if (!string.IsNullOrEmpty(Registreringsnummer))
{
VehiclePriceViewModel vehicle = new VehiclePriceViewModel();
ParkedVehicle fordon = _context.ParkedVehicle
.FirstOrDefault(v => v.RegistrationNumber == Registreringsnummer);
if (fordon != null)
{
vehicle.ParkedVehicle = fordon;
vehicle.CurrentPrice = CalculateParkingCost(fordon.StartTime);
return(View("Details", vehicle));
}
else
{
ViewData["RegNbr"] = Registreringsnummer;
parkedVehicleList = (from p in _context.ParkedVehicle
where p.RegistrationNumber.Contains(Registreringsnummer)
orderby p.RegistrationNumber
select p);
}
}
return(View(parkedVehicleList));
}
// GET: ParkedVehicles/Delete/5
public ActionResult Delete(int?id)
{
DateTime checkout = DateTime.Now;
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ParkedVehicle parkedVehicle = db.parkedVehicles.Find(id);
if (parkedVehicle == null)
{
return(HttpNotFound());
}
TimeSpan totalTime = checkout - parkedVehicle.CheckInTime;
double Initprize = 5;
if (totalTime.Days < 1)
{
parkedVehicle.ParkingPrice = Initprize * totalTime.Hours;
}
return(View(parkedVehicle));
}
public ActionResult CheckoutConfirmed(int id)
{
//ParkedVehicle parkedVehicle = db.ParkedVehicles.Find(id);
//db.ParkedVehicles.Remove(parkedVehicle);
ParkedVehicle parkedVehicle = db.ParkedVehicles.Find(id);
Receipt receipt = new Receipt();
receipt.ParkedVehicle = parkedVehicle;
new Functionalities.Calculate().UpdateReceipt(receipt);
foreach (var ps in parkedVehicle.ParkingSpaces)
{
if (ps.ParkedVehicles.Count == 1)
{
ps.IsEmpty = true;
ps.IsMcParkingSpace = false;
}
ps.TotalIncome += receipt.Cost;
ps.VisitorCount++;
ps.AverageTime =
TimeSpan.FromMinutes((int)Math
.Round(((ps.AverageTime + (receipt.CheckoutAt - receipt.CheckinAt))
.TotalMinutes) / ps.VisitorCount));
//db.Entry(ps).State = EntityState.Modified;
}
parkedVehicle.ParkingSpaces.Clear();
//db.Entry(parkedVehicle).State = EntityState.Modified;
db.Receipts.Add(receipt);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Park(ParkParkedVehicleViewModel viewModel)
{
var parkSpots = ParkingSpotContainer.GetParkSpots(_configuration);
if (ModelState.IsValid)
{
var vehicle = new ParkedVehicle();
vehicle.VehicleTypeId = int.Parse(Request.Form["Type"].ToString());
if (vehicle.VehicleTypeId == 0)
{
throw new ArgumentException("The value of the SelectItem selected was zero.");
}
var member = TempDataExtensions.Get <Member>(TempData, "member");
vehicle.MemberId = member.MemberId;
PopulateVehicleFromViewModel(viewModel, vehicle);
await ParkVehicleInBackend(parkSpots, vehicle);
vehicle.IsParked = true;
_context.Add(vehicle);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public ActionResult ConfirmCheckOut(int id)
{
ParkedVehicle vehicleDetail = db.ParkedVehicle.FirstOrDefault(v => v.Id == id);
double pricePerHour = db.Garage.FirstOrDefault().PricePerHour;
vehicleDetail.TotalPrice = TotalPrice(vehicleDetail.CheckInTime, DateTime.Now, pricePerHour);
if (vehicleDetail == null)
{
ModelState.AddModelError("RegNo", "Registreringsnumret hittades inte");
}
if (ModelState.IsValid)
{
ViewBag.AskForRegNo = false;
ViewBag.ConfirmedCheckOut = true;
ViewBag.checkedOut = false;
var checkOutViewModel = new ViewModels.CheckOutViewModel(vehicleDetail);
return(View("CheckOut", checkOutViewModel));
}
ViewBag.AskForRegNo = true;
ViewBag.ConfirmedCheckOut = false;
ViewBag.checkedOut = false;
return(View("CheckOut"));
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ParkedVehicle parkedVehicle = db.ParkedVehicle.Find(id);
if (parkedVehicle == null)
{
return(HttpNotFound());
}
var editViewModel = new ViewModels.EditViewModel(parkedVehicle);
editViewModel.VehicleTypes = db.VehicleType.ToList().Select(v => new SelectListItem
{
Selected = (v.Id == parkedVehicle.VehicleTypeId),
Value = v.Id.ToString(),
Text = v.Name
});
editViewModel.Members = db.Member.ToList().Select(v => new SelectListItem
{
Selected = (v.Id == parkedVehicle.MemberId),
Value = v.Id.ToString(),
Text = v.FullName
});
return(View(editViewModel));
}
public async Task <IActionResult> Create([Bind("Id,VehicleType,RegistrationNumber,Color,Brand,Model,TimeOfParking,NumberOfWheels")] ParkedVehicle parkedVehicle)
{
if (ModelState.IsValid)
{
parkedVehicle.TimeOfParking = DateTime.Now;
// Check whether the Vehicle with same Registration Number is Parked or not
var findRegistrationNr = _context.ParkedVehicle
.Where(rn => rn.RegistrationNumber == parkedVehicle.RegistrationNumber).ToList();
if (findRegistrationNr.Count == 0)
{
_context.Add(parkedVehicle);
}
else
{
ModelState.AddModelError("RegistrationNumber", "Vehicle with same Registration Number is already Parked");
return(View());
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(parkedVehicle));
}
public async Task <IActionResult> Create([Bind("Id,Type,RegNo,Color,Brand,Model,NoOfWheels,CheckInTime,CheckOutTime")] ParkedVehicle parkedVehicle)
{
if (ModelState.IsValid)
{
// Populate the current date and Time for checkIN field. Check whether the RegNo of the Vehicle already been parked in garage.
parkedVehicle.CheckInTime = DateTime.Now;
parkedVehicle.CheckOutTime = default(DateTime);
var findRegNo = _context.ParkedVehicle.Where(p => p.RegNo == parkedVehicle.RegNo && p.CheckOutTime == default(DateTime)).ToList();
if (findRegNo.Count == 0)
{
_context.Add(parkedVehicle);
}
else
{
ModelState.AddModelError("RegNo", "Vehicle with same Regno is parked");
return(View());
}
await _context.SaveChangesAsync();
Park(parkedVehicle.Id, (int)parkedVehicle.Type);
return(RedirectToAction(nameof(Index)));
}
return(View(parkedVehicle));
}
public ActionResult DeleteConfirmed(int id)
{
ParkedVehicle parkedVehicle = db.ParkedVehicles.Find(id);
var checkOutTime = DateTime.Now;
TimeSpan parkingDuration = checkOutTime - parkedVehicle.CheckInTime;
ViewBag.CheckOutTime = checkOutTime;
ViewBag.ParkingFee = Fee(parkingDuration);
string pDuration;
if (parkingDuration.Days > 0)
{
pDuration = $"{parkingDuration:dd} dygn {parkingDuration:hh\\:mm\\:ss} (tt:mm:ss)";
}
else
{
pDuration = $"{parkingDuration:hh\\:mm\\:ss} (tt:mm:ss)";
}
ViewBag.ParkingDuration = pDuration;
db.ParkedVehicles.Remove(parkedVehicle);
db.SaveChanges();
return(View("Receipt", parkedVehicle));
}
// GET: ParkedVehicles/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ParkedVehicle parkedVehicle = db.vehicles.Find(id);
Park park = new Park(parkedVehicle.Brand, parkedVehicle.Color, parkedVehicle.Model, parkedVehicle.ParkedTime, parkedVehicle.RegNum, parkedVehicle.NumberOfWheels, parkedVehicle.VehiclesTypeId, parkedVehicle.MemberId);
//VehiclesViewModel s = new VehiclesViewModel(parkedVehicle.Id, parkedVehicle.RegNum, parkedVehicle.VehicleTypes, DateTime.Now, parkedVehicle.ParkedTime);
if (parkedVehicle == null)
{
return(HttpNotFound());
}
parkedVehicle.Color = park.Color;
parkedVehicle.Brand = park.Brand;
parkedVehicle.Model = park.Model;
parkedVehicle.NumberOfWheels = park.NumberOfWheels;
parkedVehicle.RegNum = park.RegNum;
parkedVehicle.MemberId = park.MemberId;
parkedVehicle.VehiclesTypeId = park.VehicleTypesId;
parkedVehicle.ParkedTime = DateTime.Now;
return(View(park));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,RegNo,Color,Brand,Model,NoOfWheels,MemberId,CheckInTime")] ParkedVehicle parkedVehicle)
{
if (id != parkedVehicle.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(parkedVehicle);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ParkedVehicleExists(parkedVehicle.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["MemberId"] = new SelectList(_context.Set <Member>(), "Id", "Id", parkedVehicle.MemberId);
return(View(parkedVehicle));
}
public async Task <IActionResult> Create(ParkedVehicle parkedVehicle)
{
bool LicenceNrExists = _context.ParkedVehicle.Any
(v => v.LicenceNr == parkedVehicle.LicenceNr);
if (LicenceNrExists)
{
ModelState.AddModelError("LicenceNr", "Licence number already exists");
}
else
{
var slotIndex = GetFreeSlot(parkedVehicle.VehicleType);
if (slotIndex == null)
{
ModelState.AddModelError("LicenceNr", "No free slots for vehicle type");
}
else
{
parkedVehicle.StartLocation = slotIndex.Value;
parkedVehicle.ArrivalTime = DateTime.Now;
if (ModelState.IsValid)
{
_context.Add(parkedVehicle);
await _context.SaveChangesAsync();
//return RedirectToAction(nameof(Index));
return(RedirectToAction(nameof(LandingPageCreate)));
}
}
}
return(View(parkedVehicle));
}
public ActionResult Park(string Regnr, VehicleType Type, Color Color, string Brand, int NrofWheels, double Length, FuelType FuelType)
{
if (db.Vehicles.Any(v => v.Regnr == Regnr))
{
return(RedirectToAction("Register"));
}
ParkedVehicle vehicle = new ParkedVehicle()
{
Regnr = Regnr.ToUpper(),
Type = Type.ToString(),
Color = Color.ToString(),
Brand = Brand,
NrofWheels = NrofWheels,
Length = Length,
FuelType = FuelType.ToString(),
ParkedTime = DateTime.Now
};
if (ModelState.IsValid)
{
db.Vehicles.Add(vehicle);
db.SaveChanges();
}
return(View(vehicle));
}
public override string ToString()
{
decimal price = this.CalculatePrice();
StringBuilder sb = new StringBuilder(600);
sb.Append("*******************");
sb.Append(Environment.NewLine);
sb.Append(ParkedVehicle.ToString());
sb.Append(Environment.NewLine);
sb.Append("Rate: ");
sb.Append(ParkedVehicle.Vehicle.RegularRate.ToString("0.##"));
sb.Append(Environment.NewLine);
sb.Append("Overtime rate: ");
sb.Append(ParkedVehicle.Vehicle.OvertimeRate.ToString("0.##"));
sb.Append(Environment.NewLine);
sb.Append("--------------------");
sb.Append(Environment.NewLine);
sb.Append("Total: ");
sb.Append(price.ToString("0.##"));
sb.Append(Environment.NewLine);
sb.Append("Paid: ");
sb.Append(this.AmountPaid.ToString("0.##"));
sb.Append(Environment.NewLine);
sb.Append("Change: ");
sb.Append((this.AmountPaid - price).ToString("0.##"));
sb.Append(Environment.NewLine);
sb.Append("*******************");
return(sb.ToString());
}
/* AmountFee is no longer editable. It will not be calculated automatically from Views > ParkedVehicles > Index, Line: 71 (Linus)*/
public ActionResult Create([Bind(Include = "Id,RegNr,Color,Brand,Model,WheelsAmount,VehicleType,CheckInTime")] ParkedVehicle parkedVehicle)
{
var vehicle = db.ParkedVehicles.Where(v => v.RegNr == parkedVehicle.RegNr);
if (ModelState.IsValid && !vehicle.Any())
{
/*CheckInTime is now being defined by the user's current time when the user parks a car (Linus)*/
parkedVehicle.CheckInTime = DateTime.Parse(DateTime.Now.ToString("g"));
/*Verification random number generator*/
//var ran = new Random();
//while (true){
// do
// {
// parkedVehicle.Verification += ran.Next(0, 9);
// } while (parkedVehicle.Verification.Length != 4);
// var vehicles = db.ParkedVehicles.Where(v => v.Verification == parkedVehicle.Verification);
// if (!vehicles.Any())
// {
// break;
// }
// parkedVehicle.Verification = "";
//}
ViewBag.Description = "Fordonet har parkerats i garaget!";
db.ParkedVehicles.Add(parkedVehicle);
db.SaveChanges();
return(View());
}
ViewBag.Warning = "Det finns redan ett fordon med samma RegNr!";
return(View(parkedVehicle));
}
protected override void Seed(Garage2Mvc.DataAccesslayer.StorageContext context)
{
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data.
Member mem = new Member()
{
FirstName = "Zafar", LastName = "Iq", PhoneNo = "017345687", Email = "*****@*****.**", Address = "VårstaVägen"
};
context.Members.AddOrUpdate(m => m.PhoneNo, mem);
context.SaveChanges();
VehicleType vtype = new VehicleType()
{
VTId = 1, VTName = "Bus"
};
context.VehicleTypes.AddOrUpdate(vt => vt.VTName, vtype);
ParkedVehicle vhe = new ParkedVehicle()
{
MemberId = 9, RegistrationNumber = "ABC542", VTId = 1, Color = "Black", Brand = "Volovo", Model = "xc90", NumberOfWheels = 4, ParkTime = DateTime.Now
};
context.ParkedVehicles.AddOrUpdate(t => t.RegistrationNumber, vhe);
context.SaveChanges();
}
public ReceiptVM(ParkedVehicle v)
{
Id = v.Id;
Type = v.Type;
RegNumber = v.RegNumber;
CheckIn = v.CheckIn;
}
public async Task <IActionResult> Edit(int id, [Bind("Id,VehicleType,RegistrationNumber,NumberOfWheels,Color,Brand,Model,TimeOfParking")] ParkedVehicle parkedVehicle)
{
if (id != parkedVehicle.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(parkedVehicle);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ParkedVehicleExists(parkedVehicle.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(parkedVehicle));
}
public async Task <IActionResult> CheckIn([Bind("Id,Type,LicenseNumber,Color,Model,NumberOfWheels, MemberID")] CheckInViewModel vehicle)
{
if (ModelState.IsValid)
{
var parkedVehicle = new ParkedVehicle
{
Id = vehicle.Id,
Color = vehicle.Color,
LicenseNumber = vehicle.LicenseNumber,
Model = vehicle.Model,
NumberOfWheels = vehicle.NumberOfWheels,
TimeStampCheckIn = DateTime.Now,
MemberId = vehicle.MemberID,
VehicleTypeId = vehicle.Type
};
if (IsLicenceNumberCheckedIn(vehicle.LicenseNumber))
{
vehicle.Types = await GetTypesAsync();
vehicle.ErrorMessage = GetLicenseAlreadyParkedErrorMsg(vehicle.LicenseNumber);
return(View(vehicle));
}
_context.Add(parkedVehicle);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(ListGarage)));
}
return(View(vehicle));
}
public ActionResult DeleteConfirmed(int id)
{
ParkedVehicle parkedVehicle = db.ParkedVehicles.Find(id);
var kvittoModel = new KvittoViewModel
{
RegistrationNumber = parkedVehicle.RegistrationNumber,
CheckInTime = parkedVehicle.CheckInTime,
CheckOutTime = DateTime.Now,
ParkingTime = DateTime.Now - parkedVehicle.CheckInTime,
Customer = parkedVehicle.Customer.LastName
};
db.ParkedVehicles.Remove(parkedVehicle);
db.SaveChanges();
//Remove Parking
//var removeParkingPlace = parking.GetParkingPlaceId(parkedVehicle.Id);
//foreach (var item in removeParkingPlace)
//{
// Parking removedVehicle = db.Parkings.Find(item);
// db.Parkings.Remove(removedVehicle);
//}
//db.SaveChanges();
return(RedirectToAction("Kvitto", kvittoModel));
}
public static VehicleSpawner Create(ParkedVehicle info)
{
var vs = new GameObject().AddComponent <VehicleSpawner>();
vs.Initialize(info);
return(vs);
}
public async Task <IActionResult> CheckInVehicle([Bind("ID,VehicleType,RegNum,Color,Make,Model,NumOfWheels")] ParkedVehicle parkedVehicle)
{
if (ModelState.IsValid)
{
try
{
if (!RegNumExists(parkedVehicle.RegNum))
{
parkedVehicle.ArrivalTime = DateTime.Now;
_context.Add(parkedVehicle);
await _context.SaveChangesAsync();
}
else
{
ModelState.AddModelError("RegNum", $"{parkedVehicle.RegNum} Already parked.");
return(View());
}
}
catch (DBConcurrencyException)
{
//ToDo
if (RegNumExists(parkedVehicle.RegNum))
{
return(RedirectToAction(nameof(Feedback), new { RegNum = parkedVehicle.RegNum, Message = "The Registraion number exist, Some error occured" }));
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Feedback), new { RegNum = parkedVehicle.RegNum, Message = "Has been checked in" }));
// return RedirectToAction(nameof(Index));
}
return(View(parkedVehicle));
}
public async Task <IActionResult> Create([Bind("ID,VType,Wheels,RegistrationNumber,Manufacturer,Arrival,Color,VehicleModel")] ParkedVehicle parkedVehicle)
{
//parkedVehicle.Arrival = DateTime.Now;
parkedVehicle.RegistrationNumber = parkedVehicle.RegistrationNumber.ToUpper();
parkedVehicle.Manufacturer = char.ToUpper(parkedVehicle.Manufacturer[0]) + parkedVehicle.Manufacturer.Substring(1);
parkedVehicle.Color = char.ToUpper(parkedVehicle.Color[0]) + parkedVehicle.Color.Substring(1);
parkedVehicle.VehicleModel = char.ToUpper(parkedVehicle.VehicleModel[0]) + parkedVehicle.VehicleModel.Substring(1);
var found = _context.ParkedVehicle.FirstOrDefault(p => p.RegistrationNumber == parkedVehicle.RegistrationNumber);
if (found != null)
{
ModelState.AddModelError("RegistrationNumber", "Registration number already exists");
}
if (ModelState.IsValid)
{
_context.Add(parkedVehicle);
await _context.SaveChangesAsync();
TempData["message"] = $"Reg Nr: {parkedVehicle.RegistrationNumber} is parked!";
return(RedirectToAction(nameof(Index)));
}
return(View(parkedVehicle));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,VehicleType,RegistrationNum,Color,Brand,Model,WheelsNum,EnteringTime")] ParkedVehicle parkedVehicle)
{
if (id != parkedVehicle.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(parkedVehicle);
// _context.Entry(parkedVehicle).Property(x => x.EnteringTime).IsModified = false;
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ParkedVehicleExists(parkedVehicle.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(GeneralInfoGarage), new { @notify = "edit" }));
}
return(View(parkedVehicle));
}
//public async Task<IActionResult> Edit(int id, [Bind("Id,Type,LicenceNr,Color,Brand,Model,NrOfWheels,ArrivalTime")] ParkedVehicle parkedVehicle)
public async Task <IActionResult> Edit(int id, ParkedVehicle parkedVehicle)
{
if (id != parkedVehicle.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(parkedVehicle);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ParkedVehicleExists(parkedVehicle.Id))
{
return(NotFound());
}
else
{
throw;
}
}
//return RedirectToAction(nameof(Index));
return(RedirectToAction(nameof(LandingPageEdit)));
}
return(View(parkedVehicle));
}
public ActionResult Park([Bind(Include = "Id,Type,RegistrationNumber,Color,Brand,Model,NumberOfWheels,MemberId")] ParkedVehicle parkedVehicle)
{
if (String.IsNullOrWhiteSpace(parkedVehicle.RegistrationNumber) || String.IsNullOrWhiteSpace(parkedVehicle.Color) || String.IsNullOrWhiteSpace(parkedVehicle.Brand) ||
String.IsNullOrWhiteSpace(parkedVehicle.Model))
{
ViewBag.Message = "Please fill in all fields.";
return(View("Park"));
}
if (parkedVehicle.RegistrationNumber.Length < 6 && parkedVehicle.RegistrationNumber.Length > 8)
{
ViewBag.Message = "Please keep the Registration Number between 6 and 8 characters.";
return(View("Park"));
}
if (parkedVehicle.NumberOfWheels < 0)
{
ViewBag.Message = "Please give your vehicle a non-negative number of wheels.";
return(View("Park"));
}
parkedVehicle.TimeParked = DateTime.Now;
if (ModelState.IsValid)
{
Reciept reciept = new Reciept(parkedVehicle);
db.ParkedVehicles.Add(parkedVehicle);
db.SaveChanges();
return(RedirectToAction("Reciept", reciept));
}
return(View(parkedVehicle));
}
private static List <ParkedVehicle> GetVehicles()
{
var vehicles = new List <ParkedVehicle>();
DateTime startDateTime = new DateTime(2020, 01, 01);
for (int i = 0; i < 101; i++)
{
var vehicle = new ParkedVehicle
{
VehicleType = fake.PickRandom <VehicleType>(),
RegistrationNum = fake.Random.String2(6),
Color = fake.Commerce.Color(),
Brand = fake.Vehicle.Manufacturer(),
Model = fake.Vehicle.Model(),
WheelsNum = fake.Random.Int(0, 12),
EnteringTime = fake.Date.Between(startDateTime, DateTime.Now)
};
vehicles.Add(vehicle);
}
return(vehicles);
}
