public async Task <IActionResult> EditInventory(int id, VehicleEditViewModel viewModel)
{
ModelState.Remove("Vehicle.Customer");
ModelState.Remove("Vehicle.Salesman");
ModelState.Remove("Vehicle.Broker");
var vehicle = viewModel.Vehicle;
if (id != vehicle.VehicleId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(vehicle);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VehicleExists(vehicle.VehicleId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
viewModel.Broker = GetAllBrokers();
return(View(viewModel));
}
public async Task <IActionResult> Edit(VehicleEditViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
var vehicleEdited = _vehicleService.Get(viewModel.Id);
vehicleEdited.Number = viewModel.Number;
vehicleEdited.VIN = viewModel.VIN;
vehicleEdited.PlateNumber = viewModel.PlateNumber;
vehicleEdited.ProducerId = viewModel.ProducerId;
vehicleEdited.RegistrationDate = viewModel.RegistrationDate;
_vehicleService.Update(vehicleEdited);
return(RedirectToAction("Index"));
}
catch
{
return(View(viewModel));
}
}
else
{
return(View(viewModel));
}
}
// GET: Vehicles1/Edit/5
public async Task <IActionResult> EditInventory(int?id)
{
if (id == null)
{
return(NotFound());
}
var vehicle = _context.Vehicles.Find(id);
if (vehicle == null)
{
return(NotFound());
}
var viewModel = new VehicleEditViewModel()
{
Vehicle = vehicle,
Broker = _context.ApplicationUsers.ToList(),
};
List <ApplicationUser> brokers = GetAllBrokers();
viewModel.Broker = brokers;
if (viewModel == null)
{
return(NotFound());
}
return(View(viewModel));
}
public async Task <ActionResult> EditAsync([Bind("id,partitionKey,vin,lastServiceDate,batteryAgeDays,batteryRatedCycles,lifetimeBatteryCyclesUsed,stateVehicleRegistered")] VehicleEditViewModel item)
{
if (ModelState.IsValid)
{
var existingVehicle = await _cosmosDbService.GetItemAsync <Vehicle>(item.id, item.partitionKey);
if (existingVehicle == null)
{
return(NotFound());
}
existingVehicle.lastServiceDate = item.lastServiceDate;
existingVehicle.batteryAgeDays = item.batteryAgeDays;
existingVehicle.batteryRatedCycles = item.batteryRatedCycles;
existingVehicle.lifetimeBatteryCyclesUsed = item.lifetimeBatteryCyclesUsed;
existingVehicle.stateVehicleRegistered = item.stateVehicleRegistered;
await _cosmosDbService.UpdateItemAsync(existingVehicle, existingVehicle.partitionKey);
return(RedirectToAction("Index"));
}
// Invalid. Re-populate states list and send back to the edit form.
item.StatesList = WellKnown.StatesList;
return(View(item));
}
public IActionResult EditSoldVehicle(int?id)
{
if (id == null)
{
return(NotFound());
}
var vehicle = _context.Vehicles.Find(id);
if (vehicle == null)
{
return(NotFound());
}
var viewModel = new VehicleEditViewModel()
{
Vehicle = vehicle,
Broker = _context.ApplicationUsers.ToList(),
Customer = _context.Customers.ToList(),
Salesman = _context.ApplicationUsers.ToList()
};
List <ApplicationUser> salesman = GetAllSalesman();
List <ApplicationUser> brokers = GetAllBrokers();
List <Customer> customers = GetAllCustomers();
viewModel.Customer = customers;
viewModel.Broker = brokers;
viewModel.Salesman = salesman;
if (viewModel == null)
{
return(NotFound());
}
return(View(viewModel));
}
public async Task <ActionResult> EditAsync(string id, string pk)
{
if (id == null || pk == null)
{
return(BadRequest());
}
var item = await _cosmosDbService.GetItemAsync <Vehicle>(id, pk);
if (item == null)
{
return(NotFound());
}
var vm = new VehicleEditViewModel
{
id = item.id,
partitionKey = item.partitionKey,
vin = item.vin,
lastServiceDate = item.lastServiceDate,
batteryAgeDays = item.batteryAgeDays,
batteryRatedCycles = item.batteryRatedCycles,
lifetimeBatteryCyclesUsed = item.lifetimeBatteryCyclesUsed,
stateVehicleRegistered = item.stateVehicleRegistered,
StatesList = WellKnown.StatesList
};
return(View(vm));
}
public ActionResult EditVehicle(VehicleEditViewModel model)
{
if (ModelState.IsValid)
{
var vehicleRepo = VehicleFactory.GetVehicleRepository();
model.vehicle.UserId = GetUserId();
var oldVehicle = vehicleRepo.GetVehicleDetails(model.vehicle.VehicleId);
if (model.ImageUpload != null && model.ImageUpload.ContentLength != 0)
{
var savepath = Server.MapPath("~/Images");
string fileName = Path.GetFileNameWithoutExtension(model.ImageUpload.FileName);
string extension = Path.GetExtension(model.ImageUpload.FileName);
var filePath = Path.Combine(savepath, fileName + extension);
while (System.IO.File.Exists(filePath))
{
filePath = Path.Combine(savepath, "inventory-" + model.vehicle.VehicleId + extension);
}
WebImage img = new WebImage(model.ImageUpload.InputStream);
img.Resize(150, 100, preserveAspectRatio: false, preventEnlarge: true).Crop(1, 1);
img.Save(filePath);
model.vehicle.PictureFileName = Path.GetFileName(filePath);
var oldPath = Path.Combine(savepath, oldVehicle.PictureFileName);
if (System.IO.File.Exists(oldPath))
{
System.IO.File.Delete(oldPath);
}
}
else
{
//Did not replace the old file, so keep it
model.vehicle.PictureFileName = oldVehicle.PictureFileName;
}
vehicleRepo.UpdateVehicle(model.vehicle);
return(RedirectToAction("Vehicles"));
}
else
{
var modelEdit = new VehicleEditViewModel();
modelEdit.UserId = GetUserId();
var repo = VehicleFactory.GetVehicleRepository();
modelEdit = modelEdit.GetLists();
modelEdit.vehicle = repo.GetVehicle(model.vehicle.VehicleId);
return(View(modelEdit));
}
}
public async Task <ActionResult> DeleteConfirmedAsync([Bind("id,partitionKey")] VehicleEditViewModel item)
{
// We're just deleting the vehicle and not any related trips.
// In a real-life scenario, we'd probably just soft-delete the vehicle and any related records,
// or remove the vehicle's VIN from related trips.
await _cosmosDbService.DeleteItemAsync <Vehicle>(item.id, item.partitionKey);
return(RedirectToAction("Index"));
}
public ActionResult EditVehicle(int id)
{
var model = new VehicleEditViewModel();
model = model.GetLists();
model.UserId = GetUserId();
model.vehicle = VehicleFactory.GetVehicleRepository().GetVehicle(id);
return(View(model));
}
public async Task <IActionResult> Edit(VehicleEditViewModel inputModel)
{
if (!this.ModelState.IsValid)
{
return(this.View(inputModel));
}
await this.vehiclesService.Edit(inputModel);
int id = inputModel.Id;
return(this.RedirectToAction("Details", new { id }));
}
public ActionResult EditVehicle(int id)
{
var model = new VehicleEditViewModel();
var makeRepo = MakeRepositoryFactory.GetRepository();
var modelsRepo = ModelRepositoryFactory.GetRepository();
var vehicleRepo = VehicleRepositoryFactory.GetRepository();
model.Make = new SelectList(makeRepo.GetAll(), "MakeId", "MakeName");
model.Models = new SelectList(modelsRepo.GetAll(), "ModelId", "ModelName");
model.vehicle1 = vehicleRepo.GetById(id);
return(View(model));
}
public ActionResult VehicleEdit(int id)
{
var vm = new VehicleEditViewModel
{
Vehicle = _vehicles.Get(id),
Fuels = new SelectList(_fuels.Get(), "FuelId", "Name")
};
if (vm.Vehicle != null)
{
return(View(vm));
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
public async Task EditShouldDoNothingOnEmptyCollection()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "MyTestDb6")
.Options;
var dbContext = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository <Vehicle>(dbContext);
var service = new VehiclesService(repository);
var inputModel = new VehicleEditViewModel
{
Id = 1,
};
await service.Edit(inputModel);
Assert.Equal(0, service.GetAll().Count);
}
public IActionResult Edit(int id)
{
var vehicleToEdit = _vehicleService.Get(id);
ViewData["ProducerModelID"] = new SelectList(_producerService.GetAll(), "Id", "Name").OrderBy(x => x.Text);
VehicleEditViewModel vehicleEditViewModel = new VehicleEditViewModel
{
Id = vehicleToEdit.Id,
Number = vehicleToEdit.Number,
VIN = vehicleToEdit.VIN,
PlateNumber = vehicleToEdit.PlateNumber,
ProducerId = vehicleToEdit.ProducerId,
RegistrationDate = vehicleToEdit.RegistrationDate,
};
return(View(vehicleEditViewModel));
}
public async Task <ActionResult> Edit([Bind(Include = "ID,Name,Type,LicensePlate,LicenseExpirationDate,Mileage,NextService,EmployeeID")] VehicleEditViewModel editedVehicle)
{
try
{
if (ModelState.IsValid)
{
IVehicle vehicle = (Mapper.Map <Vehicle>(editedVehicle));
await Service.UpdateAsync(vehicle);
return(RedirectToAction("Index"));
}
}
catch (DataException)
{
ModelState.AddModelError("", "Unable to save changes. Try again and if the problem persists see your system administrator.");
}
return(View(editedVehicle));
}
public async Task EditShouldUpdateEntityWithExistingId()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "MyTestDb8")
.Options;
var dbContext = new ApplicationDbContext(options);
var newVehicle = new Vehicle
{
Id = 1,
Make = "Mercedes",
Model = "S500",
VIN = "WDB2221KZ8N654321",
NumberPlate = "CA1111PA",
FirstRegistration = new DateTime(2019, 1, 1),
Type = VehicleType.Truck,
};
dbContext.Vehicles.Add(newVehicle);
await dbContext.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Vehicle>(dbContext);
var service = new VehiclesService(repository);
var inputModel = new VehicleEditViewModel
{
Id = 1,
Make = "BMW",
Model = "760Li",
VIN = "WBNX6X6D30300G980",
NumberPlate = "CA2222PA",
FirstRegistration = "31-12-2018",
Type = "Car",
};
await service.Edit(inputModel);
Assert.Equal("BMW", service.GetById(1).Make);
Assert.Equal("760Li", service.GetById(1).Model);
Assert.Equal("WBNX6X6D30300G980", service.GetById(1).VIN);
Assert.Equal("CA2222PA", service.GetById(1).NumberPlate);
var expectedDate = new DateTime(2018, 12, 31);
Assert.Equal <DateTime>(expectedDate, service.GetById(1).FirstRegistration);
Assert.Equal <VehicleType>(VehicleType.Car, service.GetById(1).Type);
}
public async Task <IActionResult> Edit(int id, VehicleEditViewModel vehicleEditViewModel)
{
if (id != vehicleEditViewModel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var vehicle = new VehicleModel
{
Id = vehicleEditViewModel.Id,
Color = vehicleEditViewModel.Color,
Brand = vehicleEditViewModel.Brand,
Model = vehicleEditViewModel.Model,
MemberId = vehicleEditViewModel.MemberId
};
try
{
db.Entry(vehicle).State = EntityState.Modified;
db.Entry(vehicle).Property(v => v.ArrivalTime).IsModified = false;
db.Entry(vehicle).Property(v => v.RegNum).IsModified = false;
db.Entry(vehicle).Property(v => v.Type).IsModified = false;
db.Entry(vehicle).Property(v => v.VehicleTypeId).IsModified = false;
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VehicleModelExists(vehicle.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(vehicleEditViewModel));
}
public ActionResult RemoveVehicle(VehicleEditViewModel viewModel)
{
var repo = VehicleFactory.GetVehicleRepository();
var vehicle = repo.GetVehicle(viewModel.vehicle.VehicleId);
vehicle.IsDeleted = true;
var savepath = Server.MapPath("~/Images/");
string filePath = savepath + Path.GetFileName(vehicle.PictureFileName);
if (System.IO.File.Exists(filePath))
{
System.IO.File.Delete(filePath);
}
repo.UpdateVehicle(vehicle);
return(RedirectToAction("Vehicles"));
}
// GET: Vehicles/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Vehicle vehicle = db.Vehicles.Find(id);
if (vehicle == null)
{
return(HttpNotFound());
}
var editViewModel = new VehicleEditViewModel
{
Vehicle = vehicle,
VehicleTypeList = new SelectList(db.VehicleTypes.ToList(), "Id", "Name"),
};
return(View(editViewModel));
}
public async Task EditShouldDoNothingWithNonExistingId()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "MyTestDb7")
.Options;
var dbContext = new ApplicationDbContext(options);
dbContext.Vehicles.Add(new Vehicle {
Id = 1, Make = "Mercedes"
});
await dbContext.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Vehicle>(dbContext);
var service = new VehiclesService(repository);
var inputModel = new VehicleEditViewModel
{
Id = 2,
Make = "BMW",
};
await service.Edit(inputModel);
Assert.Equal("Mercedes", service.GetById(1).Make);
}
.ToList(); // Tested
public async Task Edit(VehicleEditViewModel inputModel)
{
var vehicleToUpdate = await this.vehiclesRepo.GetByIdAsync(inputModel.Id);
if (vehicleToUpdate != null)
{
vehicleToUpdate.Make = inputModel.Make;
vehicleToUpdate.Model = inputModel.Model;
vehicleToUpdate.VIN = inputModel.VIN;
vehicleToUpdate.NumberPlate = inputModel.NumberPlate;
if (!string.IsNullOrEmpty(inputModel.FirstRegistration))
{
vehicleToUpdate.FirstRegistration = DateTime.Parse(inputModel.FirstRegistration);
}
if (!string.IsNullOrEmpty(inputModel.Type))
{
vehicleToUpdate.Type = (VehicleType)Enum.Parse(typeof(VehicleType), inputModel.Type);
}
this.vehiclesRepo.Update(vehicleToUpdate);
await this.vehiclesRepo.SaveChangesAsync();
}
} // Tested
public async Task <IActionResult> Delete(VehicleEditViewModel inputModel)
{
await this.vehiclesService.Delete(inputModel.Id);
return(this.RedirectToAction("All"));
}
public ActionResult EditVehicle(VehicleEditViewModel model)
{
if (ModelState.IsValid)
{
var repo = VehicleRepositoryFactory.GetRepository();
try
{
var oldVehicle = repo.GetById(model.vehicle1.VehicleId);
if (model.ImageUpload != null && model.ImageUpload.ContentLength > 0)
{
var savepath = Server.MapPath("~/Images");
string fileName = Path.GetFileNameWithoutExtension(model.ImageUpload.FileName);
string extension = Path.GetExtension(model.ImageUpload.FileName);
var filePath = Path.Combine(savepath, fileName + extension);
int counter = 1;
while (System.IO.File.Exists(filePath))
{
filePath = Path.Combine(savepath, fileName + counter.ToString() + extension);
counter++;
}
model.ImageUpload.SaveAs(filePath);
model.vehicle1.ImageFileName = Path.GetFileName(filePath);
// delete old file
var oldPath = Path.Combine(savepath, oldVehicle.ImageFileName);
if (System.IO.File.Exists(oldPath))
{
System.IO.File.Delete(oldPath);
}
}
else
{
// they did not replace the old file, so keep the old file name
model.vehicle1.ImageFileName = oldVehicle.ImageFileName;
}
repo.Update(model.vehicle1);
return(RedirectToAction("EditVehicle", new { id = model.vehicle1.VehicleId }));
}
catch (Exception ex)
{
throw ex;
}
}
else
{
var makeRepo = MakeRepositoryFactory.GetRepository();
var modelsRepo = ModelRepositoryFactory.GetRepository();
var vehicleRepo = VehicleRepositoryFactory.GetRepository();
model.Make = new SelectList(makeRepo.GetAll(), "MakeId", "MakeName");
model.Models = new SelectList(modelsRepo.GetAll(), "ModelId", "ModelName");
model.vehicle1 = new Vehicle();
return(View(model));
}
}
public ActionResult Edit(/*[Bind(Include = "Id,RegNr,VehicleTypeId,Color,ParkingLotNumber,Model,Brand")]*/ VehicleEditViewModel editModel)
{
var vehicle = editModel.Vehicle;
if (ModelState.IsValid)
{
db.Entry(vehicle).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(vehicle));
}
