public async Task <IActionResult> Edit(int vehicleId)
{
string message = String.Empty;
var vehicle = await _vehicleServices.GetVehicle(vehicleId);
if (vehicle != null)
{
EditVehicleViewModel vehicleEdit = new EditVehicleViewModel()
{
VehicleId = vehicle.VehicleId,
LicensePlate = vehicle.LicensePlate,
VehicleName = vehicle.VehicleName,
FuelConsumptionPerTone = vehicle.FuelConsumptionPerTone,
IsAvailable = vehicle.IsAvailable,
IsInUse = vehicle.IsInUse,
VehicleBrandId = vehicle.VehicleBrandId,
Specifications = vehicle.Specifications,
VehiclePayload = vehicle.VehiclePayload,
VehicleBrands = _brandServices.GetAllBrands().ToList(),
Fuels = _fuelServices.GetFuels().ToList()
};
return(View(vehicleEdit));
}
message = "Lỗi không xác định, xin mời thao tác lại";
TempData["UserMessage"] = SystemUtilites.SendSystemNotification(NotificationType.Error, message);
return(RedirectToAction(actionName: "Index"));
}
public void UpdateVehicle(EditVehicleViewModel vehicle)
{
using (var cn = new SqlConnection(Settings.GetConnectionString()))
{
// create parameter object
var parameters = new DynamicParameters();
parameters.Add("@VehicleId", vehicle.VehicleId);
parameters.Add("@Make", vehicle.Make);
parameters.Add("@Model", vehicle.Model);
parameters.Add("@Type", vehicle.Type);
parameters.Add("@BodyStyle", vehicle.BodyStyle);
parameters.Add("@Year", vehicle.Year);
parameters.Add("@Transmission", vehicle.Transmission);
parameters.Add("@Color", vehicle.Color);
parameters.Add("@Interior", vehicle.Interior);
parameters.Add("@Mileage", vehicle.Mileage);
parameters.Add("@VIN", vehicle.VIN);
parameters.Add("@MSRP", vehicle.MSRP);
parameters.Add("@SalePrice", vehicle.SalePrice);
parameters.Add("@Description", vehicle.Description);
parameters.Add("@FeaturedVehicle", vehicle.FeaturedVehicle);
// no need to update ImageFileName, as it will stay the same even if the image changes
cn.Execute("UpdateVehicle",
parameters, commandType: CommandType.StoredProcedure);
}
}
public ActionResult EditVehicle(int id)
{
var model = new EditVehicleViewModel();
var carRepo = CarRepositoryFactory.GetRepository();
var makeModelRepo = MakeModelRepositoryFactory.GetRepository();
model.Car = carRepo.GetById(id);
model.CarMakeName = new SelectList(makeModelRepo.GetMakes(), "CarMakeId", "CarMakeName");
model.CarModelName = new SelectList(makeModelRepo.GetModelByMake(model.Car.CarMakeId), "CarModelId", "CarModelName");
model.CategoryName = new SelectList(carRepo.GetCarCategory(), "CategoryId", "CategoryName");
model.BodyStyle = new SelectList(carRepo.GetBodyStyle(), "BodyStyle", "BodyStyle");
model.Transmission = new SelectList(carRepo.GetTransmission(), "Transmission", "Transmission");
model.CarColor = new SelectList(carRepo.GetCarColor(), "CarColor", "CarColor");
model.InteriorColor = new SelectList(carRepo.GetInteriorColor(), "InteriorColor", "InteriorColor");
if (model.IsSold == null)
{
model.IsSold = false;
}
if (model.IsFeatured == null)
{
model.IsFeatured = false;
}
else
{
model.IsFeatured = true;
}
return(View(model));
}
public ActionResult Edit(int id)
{
var v = repo.GetVehicleById(id);
var model = new EditVehicleViewModel {
VehicleId = v.VehicleId,
VehicleMakeId = v.Model.VehicleMakeId,
GetModel = v.Model,
IsNew = v.VehicleIsNew,
Year = v.Year,
VIN = v.Vin,
BodyStyle = v.BodyStyle,
TransmissionType = v.TransmissionType,
Color = v.Color,
InteriorColor = v.InteriorColor,
Odometer = v.Odometer,
SalePrice = v.SalePrice,
MSRP = v.MSRP,
Description = v.Description,
ImagePath = v.Image,
Featured = v.VehicleFeatured,
};
model.SetMakes(repo.GetAllMakes());
model.SetModels(repo.GetAllModels());
return(View(model));
}
public ActionResult EditVehicle(int?id)
{
var repo = VehicleRepositoryFactory.GetVehicleRepository();
var vehicle = repo.GetVehicleById(id);
var model = new EditVehicleViewModel()
{
VehicleId = vehicle.VehicleId,
VIN = vehicle.VIN,
Interior = vehicle.Interior,
Transmission = vehicle.Transmission,
Type = vehicle.Type,
Mileage = vehicle.Mileage,
MSRP = vehicle.MSRP,
SalePrice = vehicle.SalePrice,
Color = vehicle.Color,
BodyStyle = vehicle.BodyStyle,
Description = vehicle.Description,
Make = vehicle.Make,
Model = vehicle.Model,
Year = vehicle.Year,
FeaturedVehicle = vehicle.FeaturedVehicle,
ImageFileName = vehicle.ImageFileName
};
return(View(model));
}
public void UpdateVehicle(EditVehicleViewModel v)
{
var ctxVehicle = ctx.Vehicles.FirstOrDefault(x => x.Id.Equals(v.Id));
if (ctxVehicle != null)
{
ctxVehicle.RegNr = v.RegNr;
ctxVehicle.Brand = v.Brand;
ctxVehicle.Model = v.Model;
ctxVehicle.ModelDescription = v.ModelDescription;
ctxVehicle.Year = v.Year;
ctxVehicle.Kilometer = v.Kilometer;
ctxVehicle.Price = v.Price;
ctxVehicle.Body = v.Body;
ctxVehicle.Color = v.Color;
ctxVehicle.Gearbox = v.Gearbox;
ctxVehicle.Fuel = v.Fuel;
ctxVehicle.Horsepower = v.Horsepower;
ctxVehicle.Used = v.Used;
ctxVehicle.OfficeId = v.OfficeId;
ctxVehicle.Office = v.Office;
ctxVehicle.Leasable = v.Leasable;
ctxVehicle.UpdatedDate = v.UpdatedDate;
ctxVehicle.VehicleAttribute = v.VehicleAttribute;
ctxVehicle.Images = v.Images;
}
ctx.SaveChanges();
}
public ActionResult EditVehicle(int id)
{
var model = new EditVehicleViewModel();
var repo = VehicleFactory.GetRepo();
model.BodyStyleList = new SelectList(repo.GetBodyStyle(), "BodyStyleId", "BodyStyleName");
model.CarMakeList = new SelectList(repo.GetCarMake(), "CarMakeId", "MakeName");
model.CarModelList = new SelectList(repo.GetCarModel(), "CarModelId", "ModelName");
model.CarTypeList = new SelectList(repo.GetCarType(), "TypeId", "TypeName");
model.ColorList = new SelectList(repo.GetColor(), "ColorId", "ColorName");
model.InteriorList = new SelectList(repo.GetInterior(), "InteriorId", "InteriorName");
model.TransmissionList = new SelectList(repo.GetTransmission(), "TransmissionId", "TransmissionName");
model.carMakeModel = new CarMake();
model.carModelModel = new CarModel();
model.carTypeModel = new CarType();
model.bodyStyleModel = new BodyStyle();
model.transmissionModel = new Transmission();
model.colorModel = new Color();
model.interiorModel = new Interior();
model.CarView = new Models.Tables.CarView();
model.CarWithIds = new Vehicle();
model.CarWithIds = repo.GetAllByCarId(id);
return(View(model));
}
public ActionResult EditVehicle(int id)
{
var model = new EditVehicleViewModel();
var makeRepo = new MakeRepositoryADO();
var modelRepo = new ModelRepositoryADO();
var typeRepo = new TypeRepositoryADO();
var bodystyleRepo = new BodyStyleRepositoryADO();
var transmissionRepo = new TransmissionRepositoryADO();
var colorRepo = new ColorRepositoryADO();
var interiorRepo = new InteriorRepositoryADO();
var vehicleRepo = new VehicleRepositoryADO();
model.Makes = new SelectList(makeRepo.GetAll(), "MakeID", "MakeName");
model.Models = new SelectList(modelRepo.GetAll(), "ModelID", "ModelName");
model.Types = new SelectList(modelRepo.GetAll(), "TypeID", "TypeName");
model.BodyStyles = new SelectList(modelRepo.GetAll(), "BodyID", "BodyStyleName");
model.Transmissions = new SelectList(modelRepo.GetAll(), "TransmissionID", "TransmissionType");
model.Colors = new SelectList(modelRepo.GetAll(), "ColorID", "ColorName");
model.Interiors = new SelectList(modelRepo.GetAll(), "InteriorID", "InteriorColor");
model.Vehicle = vehicleRepo.GetByID(id);
return(View(model));
}
public IActionResult Edit(int productId)
{
var vehicle = repo.Vehicles.FirstOrDefault(x => x.Id.Equals(productId));
var vm = new EditVehicleViewModel
{
Brands = ctx.Brands.Select(x => new SelectListItem
{
Text = x.Name,
Value = x.Id.ToString()
}),
Bodies = ctx.Bodies.Select(x => new SelectListItem
{
Text = x.BodyName,
Value = x.Id.ToString()
}),
Dealerships = ctx.Dealerships.Select(x => new SelectListItem
{
Text = x.City,
Value = x.Id.ToString(),
}),
Vehicle = vehicle
};
return(View(vm));
}
/// <summary>
/// Zeigt dem Benutzer ein Formular zum Editieren eines Autos an.
/// </summary>
/// <param name="id">Id des zu bearbeiten Auos.</param>
/// <returns>Eine Seite für das Bearbeiten des Autos.</returns>
public IActionResult Edit(string id)
{
// Die Liste der Autos wird aus dem Cache geladen.
if (!cache.TryGetValue(CacheKeys.VEHICLE, out vehicles))
{
vehicles = new List <IVehicle>();
}
// Ermitteln des Autos.
IVehicle modelVehicle = new Vehicle();
foreach (IVehicle v in vehicles)
{
if (v.id.Equals(id))
{
modelVehicle = v;
break;
}
}
EditVehicleViewModel model = new EditVehicleViewModel()
{
vehicle = (Vehicle)modelVehicle
};
return(View(model));
}
public async Task <bool> EditVehicle(EditVehicleViewModel model)
{
try
{
var vehicle = await GetVehicle(model.VehicleId);
if (vehicle != null)
{
if (!vehicle.IsDeleted)
{
_context.Vehicles.Attach(vehicle);
vehicle.VehicleName = model.VehicleName;
vehicle.FuelConsumptionPerTone = model.FuelConsumptionPerTone;
vehicle.IsAvailable = model.IsAvailable;
vehicle.IsInUse = model.IsInUse;
vehicle.VehicleBrandId = model.VehicleBrandId;
vehicle.Specifications = model.Specifications;
vehicle.VehiclePayload = model.VehiclePayload;
var result = await _context.SaveChangesAsync();
return(result > 0);
}
}
}
catch (Exception)
{
return(false);
}
return(false);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="oldVehicle">Vehicle to edit, or null for adding a new vehicle</param>
/// <param name="eventAggregator">Event aggregator for passing information to another viewmodel</param>
public EditVehicleView(Vehicle oldVehicle, ref EventAggregator eventAggregator)
{
InitializeComponent();
EditVehicleViewModel ViewModel = new EditVehicleViewModel(oldVehicle, ref eventAggregator);
ViewModel.RequestClose += (s, e) => this.Close();
this.DataContext = ViewModel;
}
/// <summary>
/// Beendet das Editeiren des Autos übernimmt die Änderungen.
/// </summary>
/// <param name="id">Id des Veränderten Autos.</param>
/// <param name="model">Enthält die neuen Daten.</param>
/// <returns>Eine Seite mit der Übersicht über alle Autos sowie ein Formular zum erstellen und bearbeiten.</returns>
public IActionResult EndEdit(string id, EditVehicleViewModel model)
{
// Die Liste der Autos wird aus dem Cache geladen.
if (!cache.TryGetValue(CacheKeys.VEHICLE, out vehicles))
{
vehicles = new List <IVehicle>();
}
// Ermitteln des Autos.
IVehicle vehicleCache = null;
foreach (IVehicle v in vehicles)
{
if (v.id.Equals(id))
{
vehicleCache = v;
break;
}
}
// Befüllen des Autos mit den neuen Daten.
ModelState.Clear();
var vehicle = model.vehicle;
// Stecker des Autos ermitteln.
if (vehicle.plugs == null)
{
vehicle.plugs = new List <PlugType>();
}
if (model.CCS)
{
vehicle.plugs.Add(PlugType.CCS);
}
if (model.TYPE2)
{
vehicle.plugs.Add(PlugType.TYPE2);
}
vehicle.id = id;
// Validiert das Auto.
if (!TryValidateModel(vehicle))
{
return(View("Edit", model));
}
// Übernehmen der Daten.
vehicleCache.model = vehicle.model;
vehicleCache.plugs = vehicle.plugs;
vehicleCache.socEnd = vehicle.socEnd;
vehicleCache.socStart = vehicle.socStart;
vehicleCache.capacity = vehicle.capacity;
this.model.vehicles = vehicles;
this.model.vehicle = new Vehicle();
return(RedirectToAction("Cartemplates", this.model));
}
public void EditVehicle(EditVehicleViewModel editVehicle)
{
editVehicle.Vehicle.ModelName = _carModel.FirstOrDefault(m => m.ModelID == editVehicle.Vehicle.ModelName.ModelID);
editVehicle.Vehicle.TransmissionType = _transmission.FirstOrDefault(m => m.TransmissionId == editVehicle.Vehicle.TransmissionType.TransmissionId);
editVehicle.Vehicle.BodyName = _bodyStyle.FirstOrDefault(m => m.BodyStyleId == editVehicle.Vehicle.BodyName.BodyStyleId);
_vehicleDetails.RemoveAll(v => v.VehicleId == editVehicle.Vehicle.VehicleId);
_vehicleDetails.Add(editVehicle.Vehicle);
}
public async Task <IActionResult> EditVehicle(EditVehicleViewModel model)
{
if (ModelState.IsValid)
{
var vehicle = _converterHelper.ToEditVehicle(model);
try
{
if (!await _brandRepository.ExistsAsync(vehicle.BrandId))
{
var brandName = await _brandRepository.GetBrandNameByIdAsync(vehicle.BrandId);
ModelState.AddModelError(string.Empty, $"The brand {brandName} is no longer available, please contact the company for more information");
return(View(model));
}
if (await _brandRepository.GetModelByIdAsync(vehicle.ModelId) == null)
{
var modelName = await _brandRepository.GetModelNameByIdAsync(vehicle.ModelId);
ModelState.AddModelError(string.Empty, $"The model {modelName} is no longer available, please contact the company for more information");
return(View(model));
}
if (!await _fuelRepository.ExistsAsync(vehicle.FuelId))
{
var fuelType = await _fuelRepository.GetFuelNameByIdAsync(vehicle.FuelId);
ModelState.AddModelError(string.Empty, $"The fuel {fuelType} is no longer available, please contact the company for more information");
return(View(model));
}
await _vehicleRepository.UpdateAsync(vehicle);
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
if (ex.InnerException.Message.Contains("duplicate"))
{
if (ModelState.IsValid)
{
ModelState.AddModelError(string.Empty, $"There is already a vehicle registered with the licence plate {vehicle.LicencePlate}, the change can not me made");
}
return(View(model));
}
else
{
ModelState.AddModelError(string.Empty, ex.InnerException.Message);
return(View(model));
}
}
}
return(View(model));
}
public async Task <IActionResult> Put([FromBody] EditVehicleViewModel viewModel)
{
if (!viewModel.Validate())
{
return(await ResponseBase(viewModel.Notifications));
}
var command = new EditVehicleCommand(viewModel.Chassis, viewModel.Color);
var result = await mediator.SendCommandAsync(command);
return(await ResponseBase(result));
}
public IActionResult Create(int vehicleId)
{
var vehicle = vehicleRepo.Vehicles.FirstOrDefault(x => x.Id.Equals(vehicleId));
var vm = new EditVehicleViewModel
{
DealerShips = vehicleRepo.Dealerships.ToSelectList(vehicle),
Brands = vehicleRepo.Brands.ToSelectList(vehicle),
Vehicle = vehicle,
};
return(View(vm));
}
public async Task <IActionResult> Edit(string id, [Bind("RegNum,Wheels,Model,Brand,ColorName,VehicleType,Owner")] EditVehicleViewModel editVehicle)
{
var vehicle = _context.Vehicle.Find(id);
if (vehicle == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
vehicle.Wheels = editVehicle.Wheels;
vehicle.Model = editVehicle.Model;
vehicle.Brand = editVehicle.Brand;
var owner = _context.Owners.FirstOrDefault(o => o.UserName == editVehicle.Owner);
vehicle.Owner = owner;
vehicle.MemberNumber = owner.MemberNumber;
int tempColorId = ColorSetup(editVehicle.ColorName);
vehicle.ColorId = tempColorId;
vehicle.Color = _context.Colors.Find(tempColorId);
int tempTypeId = VehicleTypeSetup(editVehicle.VehicleType);
vehicle.TypeID = tempTypeId;
vehicle.VehicleType = _context.VehicleTypes.Find(tempTypeId);
try
{
_context.Update(vehicle);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VehicleExists(vehicle.RegNum))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public IActionResult Edit(EditVehicleViewModel vm)
{
if (ModelState.IsValid)
{
vm.Vehicle.DateUpdated = DateTime.Now;
vehicleRepo.SaveVehicle(vm.Vehicle);
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(vm));
}
}
public ActionResult EditVehicle(int id)
{
EditVehicleViewModel model = new EditVehicleViewModel();
model.Vehicle = _carRepository.GetVehicle(id);
model.Makes = _carRepository.GetMakes();
model.Models = _carRepository.GetModels();
model.Interior = _carRepository.GetInterior();
model.Color = _carRepository.GetExteriors();
model.Body = _carRepository.GetBodys();
return(View(model));
}
public async Task <IActionResult> Edit(int id)
{
var vehicle = await _unitOfWork.VehicleRepository.GetVehicleByIdAsync(id);
var model = new EditVehicleViewModel
{
Id = vehicle.Id,
ModelYear = vehicle.ModelYear,
Mileage = vehicle.Mileage
};
return(View("Edit", model));
}
public async Task <IActionResult> Edit(int id)
{
var vehicle = await _service.GetVehicleAsync(id);
var model = new EditVehicleViewModel
{
Id = vehicle.Id,
ModelYear = vehicle.ModelYear,
Mileage = vehicle.Mileage
};
return(View("Edit", model));
}
public IActionResult EditIncludedVehicle(EditVehicleViewModel input)
{
if (!ModelState.IsValid)
{
var modelCarrier = _carriersService.GetCarrierByVehicleId(input.Id);
var modelVehicle = modelCarrier.Vehicles.FirstOrDefault(x => x.Id == input.Id);
return(this.View(modelVehicle));
}
var vehicle = _carriersService.EditIncludedVehicle(input.Id, input.RegNumber);
var carrier = _carriersService.GetCarrierByVehicleId(input.Id);
return(this.Redirect($"/Carriers/Edit?id={carrier.Id}"));
}
public ActionResult Edit(int Id)
{
EditVehicleViewModel model = new EditVehicleViewModel();
model.Car = _carsRepo.GetCarById(Id);
var newOrUsed = "";
if (model.Car.IsNew)
{
newOrUsed = "New";
}
else
{
newOrUsed = "Used";
}
model.AdminEditFormModel = new AdminEditFormModel
{
BodyColorId = model.Car.BodyColorId,
InteriorColorId = model.Car.InteriorColorId,
VIN = model.Car.VIN,
MakeId = model.Car.MakeId.ToString(),
ModelId = model.Car.ModelId,
Mileage = model.Car.Mileage,
ModelYear = model.Car.ModelYear,
Year = model.Car.ModelYear.Year.ToString(),
BodyStyleId = model.Car.BodyStyleId,
Description = model.Car.VehicleDetails,
TransmissionId = model.Car.TransmissionId,
Type = newOrUsed,
MSRPInput = model.Car.MSRP.ToString(),
SalePriceInput = model.Car.SalePrice.ToString()
};
model.Makes = new SelectList(_makeRepo.GetAll(), "MakeId", "MakeName", model.AdminEditFormModel.MakeId);
model.Models = new SelectList(_modelRepo.GetAll(), "ModelId", "ModelName", model.AdminEditFormModel.ModelId);
model.Transmissions = new SelectList(_transmissionRepository.GetAll(), "TransmissionId", "TransmissionType", model.AdminEditFormModel.TransmissionId);
model.Types = new List <string>()
{
"New", "Used"
};
model.BodyStyles = new SelectList(_bodyStyleRepository.GetAll(), "BodyStyleId", "BodystyleType", model.AdminEditFormModel.BodyStyleId);
model.Colors = new SelectList(_colorRepo.GetAll(), "ColorId", "ColorName", model.AdminEditFormModel.BodyColorId);
model.IntColors = new SelectList(_colorRepo.GetAll(), "ColorId", "ColorName", model.AdminEditFormModel.InteriorColorId);
return(View("EditVehicle", model));
}
public Vehicle ToEditVehicle(EditVehicleViewModel model)
{
var vehicle = new Vehicle
{
Id = model.Id,
LicencePlate = model.LicencePlate,
BrandId = model.BrandId,
ModelId = model.ModelId,
EngineCapacity = model.EngineCapacity,
FuelId = model.FuelId,
ColorId = model.ColorId,
UpdateDate = DateTime.UtcNow,
};
return(vehicle);
}
public async Task <IActionResult> Edit(EditVehicleViewModel data)
{
var vehicle = await _unitOfWork.VehicleRepository.GetVehicleByIdAsync(data.Id);
vehicle.Mileage = data.Mileage;
vehicle.ModelYear = data.ModelYear;
_unitOfWork.VehicleRepository.Update(vehicle);
if (await _unitOfWork.Complete())
{
return(RedirectToAction("Index"));
}
return(View("Error"));
}
public ActionResult EditVehicle(int id)
{
var model = new EditVehicleViewModel();
model.Vehicle = _carDealer.GetVehicleById(id);
model.SetMakeType(_carDealer.GetAllCarMakes());
model.SetModelType(_carDealer.GetAllCarModels());
model.SetBodyType(_carDealer.GetBodyStyles());
model.SetVehicleType(_carDealer.GetVehicleType());
model.SetTransmissionType(_carDealer.GetTransmissions());
model.SetColorOptions();
model.SetInteriorTypes();
//throw new Exception();
return(View(model));
}
public ActionResult Edit(EditVehicleViewModel model)
{
if (model.Image != null && model.Image.ContentLength > 0)
{
string picture = Path.GetFileName(model.Image.FileName);
string imgPath = Path.Combine(Server.MapPath("~/Images/"), picture);
model.Image.SaveAs(imgPath);
model.ImagePath = "http://localhost:53012/Images/" + model.Image.FileName;
}
if (model.SalePrice > model.MSRP)
{
ModelState.AddModelError("SalePrice", "Sale price cannot exceed MSRP");
}
if (ModelState.IsValid)
{
Vehicle editedVehicle = new Vehicle
{
VehicleId = model.VehicleId,
Vin = model.VIN,
Year = model.Year,
BodyStyle = model.BodyStyle,
Model = model.GetModel,
Image = model.ImagePath,
Color = model.Color,
InteriorColor = model.InteriorColor,
Odometer = model.Odometer,
MSRP = model.MSRP,
SalePrice = model.SalePrice,
TransmissionType = model.TransmissionType,
Description = model.Description,
VehicleFeatured = model.Featured,
VehicleIsNew = model.IsNew,
};
repo.EditVehicle(editedVehicle);
return(RedirectToAction("Admin"));
}
else
{
model.SetMakes(repo.GetAllMakes());
model.SetModels(repo.GetAllModels());
return(View(model));
}
}
public ActionResult EditVehicle(EditVehicleViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
var repo = VehicleRepositoryFactory.GetVehicleRepository();
if (viewModel.ImageUpload != null)
{
var savepath = Server.MapPath("~/Images/Vehicles");
var existingFilePath = Path.Combine(savepath, viewModel.ImageFileName);
var newFilepath = existingFilePath; // Copy the existing file path details before deleting it
// Delete the existing file first
if (System.IO.File.Exists(existingFilePath))
{
System.IO.File.Delete(existingFilePath);
}
string extension = Path.GetExtension(viewModel.ImageUpload.FileName);
viewModel.ImageUpload.SaveAs(newFilepath);
}
repo.UpdateVehicle(viewModel);
return(RedirectToAction("Index", "Home"));
}
catch (Exception ex)
{
throw ex;
}
}
else
{
var vehicleViewObject = new AddVehicleViewModel();
return(View(vehicleViewObject));
}
}
public async Task <IActionResult> Edit(EditVehicleViewModel model)
{
string message = String.Empty;
model.VehicleBrands = _brandServices.GetAllBrands().ToList();
model.Fuels = _fuelServices.GetFuels().ToList();
if (ModelState.IsValid)
{
if (await _vehicleServices.EditVehicle(model))
{
message = "Thông tin phương tiện đã được điều chỉnh";
TempData["UserMessage"] = SystemUtilites.SendSystemNotification(NotificationType.Success, message);
return(RedirectToAction(actionName: "Index"));
}
}
message = "Lỗi không xác định, xin mời thao tác lại";
TempData["UserMessage"] = SystemUtilites.SendSystemNotification(NotificationType.Error, message);
return(View(model));
}
