public async Task <IActionResult> Edit(VehicleMakeDTO vehicleMakeDTO)
{
VehicleMake make = Mapper.Map <VehicleMake>(vehicleMakeDTO);
await MakeService.UpdateAsync(make);
return(RedirectToAction(nameof(Index)));
}
public ActionResult Create()
{
var makeDTO = new VehicleMakeDTO();
SetMessage();
return(View(makeDTO));
}
public async Task <IServiceResponse <bool> > UpdateVehicleMake(int id, VehicleMakeDTO vehicleMake)
{
return(await HandleApiOperationAsync(async() => {
await _vehicleMakeService.UpdateVehicleMake(id, vehicleMake);
return new ServiceResponse <bool>(true);
}));
}
public async Task <IServiceResponse <bool> > AddVehicleMake(VehicleMakeDTO vehicleMake)
{
return(await HandleApiOperationAsync(async() => {
await _vehicleMakeService.AddVehicleMake(vehicleMake);
return new ServiceResponse <bool>(true);
}));
}
public async Task <IActionResult> Edit(int id)
{
if (!MakeService.MakeIdExist(id))
{
return(NotFound());
}
VehicleMakeDTO makeDTO = Mapper.Map <VehicleMakeDTO>(await MakeService.GetOneVehicleMakerAsync(id));
return(View(makeDTO));
}
public async Task <IActionResult> Create([Bind("Id,Name,Abrv")] VehicleMakeDTO vehicleMake)
{
if (ModelState.IsValid)
{
var dto = _mapper.Map <VehicleMake>(vehicleMake);
await _make.CreateAsync(dto);
return(RedirectToAction(nameof(Index)));
}
return(View(vehicleMake));
}
public async Task <ActionResult> Delete(int id, VehicleMakeDTO collection)
{
try
{
await _vehicleMakeService.DeleteAsync(id);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public async Task <ActionResult> Edit(int id, VehicleMakeDTO collection)
{
try
{
await _vehicleMakeService.Update(collection);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public async Task UpdateVehicleMake(int id, VehicleMakeDTO vehicleMake)
{
var model = await _vehicleMakeRepo.GetAsync(id);
if (model == null)
{
throw await _serviceHelper.GetExceptionAsync(ErrorConstants.VEHICLE_MAKE_NOT_EXIST);
}
model.Name = vehicleMake.Name;
await _unitOfWork.SaveChangesAsync();
}
public async Task <IActionResult> Edit(VehicleMakeDTO vehicleMakeDTO)
{
if (ModelState.IsValid)
{
VehicleMake make = Mapper.Map <VehicleMake>(vehicleMakeDTO);
await MakeService.UpdateAsync(make);
return(RedirectToAction(nameof(Index)));
}
else
{
return(View());
}
}
public async Task <IActionResult> Create(VehicleMakeDTO makeDTO)
{
if (ModelState.IsValid)
{
var vehicleMake = Mapper.Map <VehicleMake>(makeDTO);
await MakeService.AddVehicleMakerAsync(vehicleMake);
return(RedirectToAction(nameof(Index)));
}
else
{
return(View());
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,Abrv")] VehicleMakeDTO vehicleMake)
{
if (id != vehicleMake.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var dto = _mapper.Map <VehicleMake>(vehicleMake);
await _make.UpdateAsync(dto);
return(RedirectToAction(nameof(Index)));
}
return(View(vehicleMake));
}
public async Task AddVehicleMake(VehicleMakeDTO vehicleMakeDto)
{
vehicleMakeDto.Name = vehicleMakeDto.Name.Trim();
if (await _vehicleMakeRepo.ExistAsync(v => v.Name == vehicleMakeDto.Name))
{
throw await _serviceHelper.GetExceptionAsync(ErrorConstants.VEHICLE_MAKE_EXIST);
}
_vehicleMakeRepo.Insert(new VehicleMake
{
Name = vehicleMakeDto.Name,
CreatorUserId = _serviceHelper.GetCurrentUserId()
});
await _unitOfWork.SaveChangesAsync();
}
public async Task <ActionResult> Create(VehicleMakeDTO collection)
{
if (ModelState.IsValid)
{
try
{
await _vehicleMakeService.InsertAsync(collection);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
return(Content(e.Message.ToString()));
}
}
else
{
return(View());
}
}
public async Task <ActionResult> Create([Bind(Include = "Name, Abrv")] VehicleMakeDTO model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var newMake = _vehicleMake;
Mapper.Map(model, newMake);
try
{
await _makeService.AddAsync(newMake);
TempData["Message"] = $"Make: {model.Name} ({model.Abrv}) successfully added to the database.";
}
catch (Exception e)
{
TempData["Message"] = $"Something went wrong: {e.Message}";
return(View(model));
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Edit([Bind(Include = "Id, Name, Abrv")] VehicleMakeDTO model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var makeToUpdate = await _makeService.FindAsync(model.Id);
Mapper.Map(model, makeToUpdate);
try
{
await _makeService.UpdateAsync(makeToUpdate);
TempData["Message"] = $"Make: {model.Name} ({model.Abrv}) successfully updated.";
}
catch (Exception e)
{
TempData["Message"] = $"Something went wrong: {e.Message}";
return(View(model));
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Edit(int id)
{
VehicleMakeDTO makeDTO = Mapper.Map <VehicleMakeDTO>(await MakeService.GetOneVehicleMakerAsync(id));
return(View(makeDTO));
}
