public async Task <IActionResult> UpdateAsync(Guid?id, VehicleMakeView vehicle)
{
try
{
if (id == null)
{
return(BadRequest());
}
IVehicleMakeDomain vehicleUpdate = await _service.GetIdMakeAsync(vehicle.Id);
if (vehicleUpdate == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
await _service.UpdateMakeAsync(_mapper.Map <IVehicleMakeDomain>(vehicle));
}
}
catch
{
return(NotFound());
}
return(NoContent());
}
public async Task <HttpResponseMessage> Update(VehicleMakeView vehicleMakeView)
{
try
{
var toBeUpdated = await MakeService.Read(vehicleMakeView.VehicleMakeId);
if (toBeUpdated == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Model not found"));
}
if (vehicleMakeView.Name != null)
{
toBeUpdated.Name = vehicleMakeView.Name;
}
if (vehicleMakeView.Abrv != null)
{
toBeUpdated.Abrv = vehicleMakeView.Abrv;
}
var response = await MakeService.Update(AutoMapper.Mapper.Map <VehicleMakeDomain>(toBeUpdated));
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
catch
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Couldn't update data. Database error."));
}
}
public void MakeControllerGetAllTest()
{
//Arange
IncludeAllMappings.include();
var context = new VehicleContext();
var repository = new Repository.Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var makeRepository = new MakeRepository(repository);
var modelRepository = new ModelRepository(repository);
var makeService = new MakeService(makeRepository, modelRepository);
var testController = new MakeController(makeService);
testController.Request = new HttpRequestMessage();
testController.Configuration = new HttpConfiguration();
//Add make
var vMake = new VehicleMakeView()
{
Name = "MakeControllerGetAllTest", Abrv = "MakeControllerGetAllTest"
};
Task.Run(async() =>
{
var response = await testController.Add(vMake);
Assert.IsNotNull(response);
}).GetAwaiter().GetResult();
Task.Run(async() =>
{
//Act
var result = await testController.GetAll();
//Assert
Assert.IsNotNull(result);
}).GetAwaiter().GetResult();
}
public ActionResult Delete(VehicleMakeView makes)
{
try
{
make.Delete(Mapper.Map <VehicleMake>(makes));
return(RedirectToAction("Index"));
}
catch (Exception) { }
return(RedirectToAction("Delete", makes.Id));
}
public async Task <IActionResult> Create(
[Bind("Name,Abrv")] VehicleMakeView vehicle)
{
if (ModelState.IsValid)
{
var create = mapper.Map <IVehicleMake>(vehicle);
await service.InsertMake(create);
return(RedirectToAction("Index"));
}
return(View(vehicle));
}
public async Task <IActionResult> EditSave(
[Bind("Id,Name,Abrv")] VehicleMakeView vehicle)
{
if (ModelState.IsValid)
{
var update = mapper.Map <IVehicleMake>(vehicle);
await service.UpdateMake(update);
return(RedirectToAction("Index"));
}
return(View(vehicle));
}
public ActionResult Create([Bind(Include = "Name,Abrv")] VehicleMakeView makes)
{
try
{
if (ModelState.IsValid)
{
make.Create(Mapper.Map <VehicleMake>(makes));
return(RedirectToAction("Index"));
}
}
catch (DataException) { }
return(RedirectToAction("Create"));
}
public ActionResult Edit([Bind(Include = "Id,Name,Abrv")] VehicleMakeView makes)
{
try
{
if (ModelState.IsValid)
{
make.Edit(Mapper.Map <VehicleMake>(makes));
return(RedirectToAction("Index"));
}
}
catch (DataException) { }
return(RedirectToAction("Edit", makes.Id));
}
public void MakeControllerUpdateTest()
{
//Arange
IncludeAllMappings.include();
var context = new VehicleContext();
var repository = new Repository.Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var makeRepository = new MakeRepository(repository);
var modelRepository = new ModelRepository(repository);
var makeService = new MakeService(makeRepository, modelRepository);
var testController = new MakeController(makeService);
testController.Request = new HttpRequestMessage();
testController.Configuration = new HttpConfiguration();
//Add make
var vMake = new VehicleMakeView()
{
Name = "MakeControllerUpdateTest", Abrv = "MakeControllerUpdateTest"
};
Task.Run(async() =>
{
var response = await testController.Add(vMake);
Assert.IsNotNull(response);
}).GetAwaiter().GetResult();
//Get make
VehicleMakeView targetItem = null;
JavaScriptSerializer JSS = new JavaScriptSerializer();
Task.Run(async() =>
{
var response = await testController.GetAll();
Assert.IsNotNull(response);
IEnumerable <VehicleMakeView> obj = JSS.Deserialize <IEnumerable <VehicleMakeView> >(response.Content.ReadAsStringAsync().Result);
targetItem = obj.LastOrDefault();
}).GetAwaiter().GetResult();
targetItem.Name = "MakeControllerUpdateTestTested";
Task.Run(async() =>
{
//Act
var response = await testController.Update(targetItem);
//Assert
int obj = JSS.Deserialize <int>(response.Content.ReadAsStringAsync().Result);
Assert.AreEqual(1, obj);
}).GetAwaiter().GetResult();
}
public async Task <IActionResult> GetAsync(Guid?id)
{
if (id == null)
{
return(BadRequest());
}
VehicleMakeView getVehicle = _mapper.Map <VehicleMakeView>(await _service.GetIdMakeAsync(id));
if (getVehicle == null)
{
return(NotFound());
}
return(Ok(getVehicle));
}
public async Task <IActionResult> Details(Guid?id)
{
if (id == null)
{
return(BadRequest());
}
var vehicle = await service.GetIdMake(id);
if (vehicle == null)
{
return(NotFound());
}
VehicleMakeView getVehicle = mapper.Map <VehicleMakeView>(vehicle);
return(View(getVehicle));
}
public async Task <IActionResult> CreateAsync(VehicleMakeView vehicle)
{
try
{
if (ModelState.IsValid)
{
await _service.InsertMakeAsync(_mapper.Map <IVehicleMakeDomain>(vehicle));
return(Ok());
}
return(BadRequest());
}
catch
{
return(StatusCode(500));
}
}
public async Task <HttpResponseMessage> Add(VehicleMakeView vehicleMakeView)
{
try
{
if (vehicleMakeView.Name == null || vehicleMakeView.Abrv == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Model is not complete. Please provide name and abrv"));
}
vehicleMakeView.VehicleMakeId = Guid.NewGuid();
var response = await MakeService.Add(AutoMapper.Mapper.Map <VehicleMakeDomain>(vehicleMakeView));
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
catch
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Couldn't add data. Database error."));
}
}
public async Task <IActionResult> Delete(Guid?id, bool?saveChangesError = false)
{
if (id == null)
{
return(BadRequest());
}
var vehicle = await service.GetIdMake(id);
if (vehicle == null)
{
return(NotFound());
}
VehicleMakeView getVehicle = mapper.Map <VehicleMakeView>(vehicle);
if (saveChangesError.GetValueOrDefault())
{
ViewData["ErrorMessage"] = Strings.DeleteError;
}
return(View(getVehicle));
}
