public async Task <HttpResponseMessage> Update(VehicleMakeViewModel make)
{
try
{
var toBeUpdated = await MakeService.GetByMakeIDAsync(make.MakeID);
if (toBeUpdated == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "make not found"));
}
if (make.MakeName != null)
{
toBeUpdated.MakeName = make.MakeName;
}
if (make.MakeAbrv != null)
{
toBeUpdated.MakeAbrv = make.MakeAbrv;
}
var response = await MakeService.UpdateAsync(Mapper.Map <VehicleMake>(toBeUpdated));
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
catch
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "couldn't update make. database error"));
}
}
public async Task <ActionResult> EditVehicleMake(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var vehicleMakeToUpdate = await _vehicleMakeService.GetVehicleMakeByIDAsync(id);
if (TryUpdateModel(vehicleMakeToUpdate, "", new[] { "Name", "Abbreviation" }))
{
try
{
await _vehicleMakeService.EditVehicle(vehicleMakeToUpdate);
return(RedirectToAction("Index"));
}
catch (DataException dex)
{
ModelState.AddModelError("Err", dex);
}
}
VehicleMakeViewModel vehicleMakeViewModels = _mapper.Map <VehicleMakeViewModel>(vehicleMakeToUpdate);
return(View(vehicleMakeViewModels));
}
// GET: Vehicles
public async Task <IActionResult> Index(string vehicleMake, string searchString)
{
IQueryable <string> genreQuery = from v in _context.Vehicle
orderby v.Make
select v.Make;
var vehicles = from m in _context.Vehicle
select m;
if (!String.IsNullOrEmpty(searchString))
{
vehicles = vehicles.Where(s => s.Model.Contains(searchString));
}
if (!String.IsNullOrEmpty(vehicleMake))
{
vehicles = vehicles.Where(x => x.Make == vehicleMake);
}
var VehicleMakeVM = new VehicleMakeViewModel();
VehicleMakeVM.makers = new SelectList(await genreQuery.Distinct().ToListAsync());
VehicleMakeVM.vehicles = await vehicles.ToListAsync();
return(View(VehicleMakeVM));
}
//POST-Create
public async Task <IActionResult> CreatePost(VehicleMakeViewModel newViewModel)
{
var newMake = mapper.Map <VehicleMake>(newViewModel);
await vehicleMakeService.CreateMakeAsync(newMake);
return(RedirectToAction("Index"));
}
// GET: Vehicles
/*public async Task<IActionResult> Index()
* {
* return View(await _context.Vehicle.ToListAsync());
* }*/
public async Task <IActionResult> Index(string vehicleMake, string searchString)
{
IQueryable <string> makeQuery = from m in _context.Vehicle
orderby m.VehicleMake
select m.VehicleMake;
var vehicles = from m in _context.Vehicle
select m;
if (!string.IsNullOrEmpty(searchString))
{
vehicles = vehicles.Where(s => s.VehicleModel.Contains(searchString));
}
if (!string.IsNullOrEmpty(vehicleMake))
{
vehicles = vehicles.Where(m => m.VehicleMake == vehicleMake);
}
var vehicleMakeVM = new VehicleMakeViewModel
{
Makes = new SelectList(await makeQuery.Distinct().ToArrayAsync()),
Vehicles = await vehicles.ToListAsync()
};
return(View(vehicleMakeVM));
}
//POST-Edit
public async Task <IActionResult> EditPost(VehicleMakeViewModel updatedViewModel)
{
var updatedMake = mapper.Map <VehicleMake>(updatedViewModel);
await vehicleMakeService.UpdateMakeAsync(updatedMake);
return(RedirectToAction("Index"));
}
// GET: VehicleMake/Delete/5
public async Task <ActionResult> Delete(int id)
{
VehicleMakeViewModel model = new VehicleMakeViewModel();
var vehicle = await MakeService.GetByIdAsync(id);
model = Mapper.Map <VehicleMakeModel, VehicleMakeViewModel>(vehicle);
return(View(model));
}
public ActionResult Edit([Bind(Include = "Id,Name,Abrv")] VehicleMakeViewModel vehicleMakeView)
{
if (ModelState.IsValid)
{
vehicleService.EditVehicleMake(vehicleMakeView);
return(RedirectToAction("Index"));
}
return(View(vehicleMakeView));
}
public async Task <ActionResult> Edit(VehicleMakeViewModel vehicleMakeChanges)
{
if (ModelState.IsValid)
{
var mappedVehicleMakeChanges = Mapper.Map <IVehicleMake>(vehicleMakeChanges);
await Service.UpdateVehicleMakeAsync(mappedVehicleMakeChanges);
}
return(RedirectToAction(nameof(Index)));
}
public void Add(VehicleMakeViewModel makeVM)
{
VehicleMake make = new VehicleMake();
Mapper.Map(makeVM, make);
make.Id = Guid.NewGuid();
_db.VehicleMake.Add(make);
_db.SaveChanges();
}
public ActionResult Create([Bind(Include = "Id,Name,Abrv")] VehicleMakeViewModel vehicleMakeViewModel)
{
if (ModelState.IsValid)
{
_service.Add(vehicleMakeViewModel);
return(RedirectToAction("Index"));
}
return(View(vehicleMakeViewModel));
}
public async Task <ActionResult> Edit([Bind(Include = "Name,Abrv")] VehicleMakeViewModel VehicleMake)
{
if (ModelState.IsValid)
{
await Service.UpdateAsync(AutoMapper.Mapper.Map <VehicleMakePoco>(VehicleMake));
return(RedirectToAction("Index"));
}
return(View());
}
// PUT: api/makes/:id
public async Task <IHttpActionResult> Put(int id, [FromBody] VehicleMakeViewModel make)
{
if (make == null)
{
return(BadRequest("Vehicle data not entered"));
}
await Service.EditMake(Mapper.Map <IVehicleMake>(make));
return(Ok());
}
public ActionResult Edit([Bind(Include = "Id,Name,Abrv")] VehicleMakeViewModel vehicleMakeVM)
{
if (ModelState.IsValid)
{
VehicleMake vehicleMake = Mapper.Map <VehicleMake>(vehicleMakeVM);
vehicleMakeLogic.UpdateVehicleMake(vehicleMake);
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index"));
}
public async Task <HttpResponseMessage> PutVehicleMake(Guid id, VehicleMakeViewModel vehicleMake)
{
if (ModelState.IsValid)
{
var vehicleMakes = await _vehicleMakeService.UpdateVehicleMake(Mapper.Map <VehicleMakeDomainModel>(vehicleMake));
return(Request.CreateResponse(HttpStatusCode.OK, vehicleMakes));
}
return(Request.CreateResponse(HttpStatusCode.InternalServerError, "error, can't update"));
}
public async Task <ActionResult> Create(VehicleMakeViewModel vehicleMake)
{
if (ModelState.IsValid)
{
var mappedVehicleMake = Mapper.Map <VehicleMake>(vehicleMake);
await Service.AddVehicleMakeAsync(mappedVehicleMake);
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public ActionResult ManageVehicleMake(VehicleMakeViewModel vehicle)
{
// Check Model.
if (ModelState.IsValid)
{
vehicle = Mapper.Map <VehicleMakeViewModel>(Factory.Save(vehicle as IVehicleMakeDto));
SelectListItemCache.ClearCache(SelectListItemCacheType.InsuranceCompany);
}
return(PartialView("_VehicleMakeManage", vehicle));
}
public ActionResult Create([Bind(Include = "Id,Name,Abrv")] VehicleMakeViewModel vehicleMakeVM)
{
if (ModelState.IsValid)
{
VehicleMake vehicleMake = Mapper.Map <VehicleMake>(vehicleMakeVM);
vehicleMakeLogic.InsertVehicleMake(vehicleMake);
return(RedirectToAction("Index"));
}
return(View("~/Views/Admin/VehicleMakes/Index.cshtml"));
}
public ActionResult Create([Bind(Include = "Id,Name,Abrv")] VehicleMakeViewModel vehicleMakeView)
{
vehicleMakeView.Id = Guid.NewGuid();
if (ModelState.IsValid)
{
vehicleService.CreateVehicleMake(vehicleMakeView);
return(RedirectToAction("Index"));
}
return(View(vehicleMakeView));
}
//POST: api/makes
public async Task <IHttpActionResult> Post([FromBody] VehicleMakeViewModel make)
{
if (make == null)
{
return(BadRequest("Vehicle data not entered"));
}
var createdMakeWithId = await Service.CreateMake(Mapper.Map <IVehicleMake>(make));
return(Created(Request.RequestUri + make.ToString(), Mapper.Map <VehicleMakeViewModel>(createdMakeWithId)));
}
public async Task <ActionResult> Create(VehicleMakeViewModel model)
{
if (ModelState.IsValid)
{
var vehicle = Mapper.Map <VehicleMakeViewModel, IVehicleMake>(model);
Mapper.AssertConfigurationIsValid();
await vehiclemakeService.CreateAsync(vehicle);
return(RedirectToAction("Index"));
}
return(View(model));
}
public async Task <IHttpActionResult> CreateVehicleMake(VehicleMakeViewModel vehicleMakeViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
VehicleMake vehicleMake = iMapper.Map <VehicleMake>(vehicleMakeViewModel);
await _vehicleService.CreateVehicleMake(vehicleMake);
return(CreatedAtRoute("DefaultApi", new { id = vehicleMakeViewModel.MakeId }, vehicleMakeViewModel));
}
public async Task <ActionResult> Create([Bind(Include = "Id,Name,Abrv")] VehicleMake vehicleMake)
{
if (ModelState.IsValid)
{
await _vehicleService.InsertMake(vehicleMake);
return(RedirectToAction("Index"));
}
VehicleMakeViewModel viewModel = _mapper.Map <VehicleMakeViewModel>(vehicleMake);
return(View(viewModel));
}
public async Task <IHttpActionResult> GetVehicleMakeByID(int?id)
{
IVehicleMake vehicleMake = await _vehicleMakeService.GetVehicleMakeByID(id);
if (vehicleMake == null)
{
return(NotFound());
}
VehicleMakeViewModel vehicleMakeViewModels = _mapper.Map <VehicleMakeViewModel>(vehicleMake);
return(Ok(vehicleMakeViewModels));
}
public async Task <IActionResult> DeleteVehicleMakeAsync(VehicleMakeViewModel vehicleMakeViewModel)
{
try
{
await vehicleMakeService.DeleteVehicleMakeAsync(mapper.Map <IVehicleMakeDTO>(vehicleMakeViewModel));
return(RedirectToAction(nameof(GetVehicleMakeAsync)));
}
catch (Exception e)
{
return(View());
}
}
public async Task <ActionResult> Edit(int id)
{
VehicleMakeViewModel model = new VehicleMakeViewModel();
var vehicle = await vehiclemakeService.GetByIdAsync(id);
if (vehicle == null)
{
return(HttpNotFound());
}
model = Mapper.Map <IVehicleMake, VehicleMakeViewModel>(vehicle);
Mapper.AssertConfigurationIsValid();
return(View(model));
}
public async Task <IHttpActionResult> GetVehicleMake(int id)
{
IVehicleMake vehicleMake = await _vehicleService.FindVehicleMake(id);
if (vehicleMake == null)
{
return(NotFound());
}
VehicleMakeViewModel vehicleMakeViewModel = iMapper.Map <VehicleMakeViewModel>(vehicleMake);
return(Ok(vehicleMakeViewModel));
}
public async Task <ActionResult> Delete(VehicleMakeViewModel model)
{
var vehicle = Mapper.Map <VehicleMakeViewModel, VehicleMake>(model);
Mapper.AssertConfigurationIsValid();
if (vehicle != null)
{
await vehiclemakeService.DeleteAsync(vehicle.Id);
return(RedirectToAction("Index"));
}
return(View(model));
}
//// GET: VehicleMake/Edit/5
public ActionResult Edit(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
VehicleMakeViewModel vehicleMakeVM = vehicleService.FindIdMake(id);
if (vehicleMakeVM == null)
{
return(HttpNotFound());
}
return(View(vehicleMakeVM));
}
public async Task <ActionResult> Edit(VehicleMakeViewModel model)
{
try
{
var vehicle = Mapper.Map <VehicleMakeViewModel, VehicleMakeModel>(model);
await MakeService.UpdateAsync(vehicle);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
