public async Task <HttpResponseMessage> Add(VehicleModelViewModel model)
{
try
{
if (model.ModelName == null || model.ModelAbrv == null || model.MakeID == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "model is not complete, please provide name, abrv and make id"));
}
var IfMakeExist = await MakeService.GetByMakeIDAsync(model.MakeID);
if (IfMakeExist == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "invalid MakeID"));
}
model.ModelID = Guid.NewGuid();
model.MakeID = Guid.NewGuid();
model.ModelName = null;
model.ModelAbrv = null;
var response = await ModelService.AddAsync(model.MakeID, model.ModelID, model.ModelName, model.ModelAbrv);
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
catch
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "couldn't add model, database error"));
}
}
public async Task <ActionResult> Add(VehicleModelViewModel model)
{
try
{
var result = await _modelRepo.GetModelByName(model.Description);
if (result != null)
{
return(BadRequest("Bilmodellen existerar redan i systemet!"));
}
var newModel = new VehicleModel
{
Description = model.Description
};
_modelRepo.Add(newModel);
if (await _modelRepo.SaveAllAsync())
{
return(StatusCode(201, newModel));
}
return(StatusCode(500, "Det gick inte att spara ner ny bilmodell"));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public async Task <HttpResponseMessage> Update(VehicleModelViewModel model)
{
try
{
var toBeUpdated = await ModelService.GetByModelIDAsync(model.ModelID);
if (model.ModelName != null)
{
toBeUpdated.ModelName = model.ModelName;
}
if (model.ModelAbrv != null)
{
toBeUpdated.ModelAbrv = model.ModelAbrv;
}
var response = await ModelService.UpdateAsync(model.MakeID, model.ModelID, model.ModelName, model.ModelAbrv);
if (response == 0)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "couldn't update model"));
}
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
catch
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "couldn't update model. database error"));
}
}
public async Task <ActionResult> EditVehicleModel(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var vehicleModelToUpdate = await _vehicleModelService.GetVehicleModelByIDAsync(id);
if (TryUpdateModel(vehicleModelToUpdate, "", new string[] { "VehicleMakeId", "Name", "Abbreviation" }))
{
try
{
await _vehicleModelService.EditVehicleModel(vehicleModelToUpdate);
return(RedirectToAction("Index"));
}
catch (DataException dex)
{
ModelState.AddModelError("Err", dex);
}
}
VehicleModelViewModel vehicleModelViewModel =
_mapper.Map <VehicleModelViewModel>(vehicleModelToUpdate);
return(View(vehicleModelViewModel));
}
public ActionResult Edit(int id, VehicleModelViewModel collection)
{
try
{
if (id > 0)
{
if (ModelState.IsValid)
{
var model = _mapper.Map <VehicleModel>(collection);
model.UpdaterId = LogedInAdmin.Id;
_vehicleModelService.Update(model);
return(RedirectToAction("Index"));
}
ModelState.AddModelError(string.Empty, GeneralMessages.DefectiveEntry);
}
else
{
ModelState.AddModelError(string.Empty, GeneralMessages.EmptyId);
}
}
catch (Exception ex)
{
_logger.Error(ex);
if (ex.InnerException != null && ex.InnerException.Source.Equals(GeneralMessages.ExceptionSource))
{
ModelState.AddModelError(string.Empty, ex.Message);
}
else
{
ModelState.AddModelError(string.Empty, GeneralMessages.UnexpectedError);
}
}
return(View(collection));
}
// GET: VehicleModel/Create
public async Task <ActionResult> Create(Guid id)
{
var model = new VehicleModelViewModel()
{
VehicleMakeId = id
};
return(await Task.FromResult(View(model)));
}
public async Task <ActionResult> Edit(VehicleModelViewModel vehicleModelChanges)
{
if (ModelState.IsValid)
{
var mappedVehicleModelChanges = Mapper.Map <IVehicleModel>(vehicleModelChanges);
await Service.UpdateVehicleModelAsync(mappedVehicleModelChanges);
}
return(RedirectToAction(nameof(Index), new { id = vehicleModelChanges.VehicleMakeId }));
}
public ActionResult Edit([Bind(Include = "Id,Name,Abrv,Make_Id")] VehicleModelViewModel vehicleModelViewModel)
{
if (ModelState.IsValid)
{
_serviceModel.Edit(vehicleModelViewModel);
return(RedirectToAction("Index"));
}
return(View(vehicleModelViewModel));
}
public static VehicleModel SetDataToVehicleModel(VehicleModelViewModel pVehicleModel)
{
VehicleModel oVehicleModel = new VehicleModel();
int idVehicleModel = int.Parse(pVehicleModel.id.ToString());
oVehicleModel.vehMdl_id = idVehicleModel;
oVehicleModel.vehMdl_name = pVehicleModel.name;
return(oVehicleModel);
}
public void Add(VehicleModelViewModel modelVM)
{
VehicleModel model = new VehicleModel();
Mapper.Map(modelVM, model);
_db.VehicleModel.Add(model);
_db.SaveChanges();
}
public ActionResult Edit([Bind(Include = "VehicleModelId,VehicleMakeId,Name,Abrv")] VehicleModelViewModel vehicleModelVM)
{
if (ModelState.IsValid)
{
vehicleService.EditVehicleModel(vehicleModelVM);
return(RedirectToAction("Index"));
}
ViewBag.VehicleMakeId = new SelectList(vehicleService.GetAllVehicleMakes(), "Id", "Name", vehicleModelVM.VehicleMakeId);
return(View(vehicleModelVM));
}
// PUT: api/models/:id
public async Task <IHttpActionResult> Put(int id, [FromBody] VehicleModelViewModel model)
{
if (model == null)
{
return(BadRequest("Vehicle data not entered"));
}
await Service.EditModel(Mapper.Map <IVehicleModel>(model));
return(Ok());
}
public ActionResult Edit([Bind(Include = "Id,Name,Abrv,VehicleMakeId")] VehicleModelViewModel vehicleModelVM)
{
if (ModelState.IsValid)
{
VehicleModel vehicleModel = Mapper.Map <VehicleModel>(vehicleModelVM);
vehicleModelLogic.UpdateVehicleModel(vehicleModel);
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index"));
}
public ActionResult Create([Bind(Include = "Id,Name,Abrv,Make_Id")] VehicleModelViewModel vehicleModelViewModel)
{
if (ModelState.IsValid)
{
vehicleModelViewModel.Id = Guid.NewGuid();
_serviceModel.Add(vehicleModelViewModel);
return(RedirectToAction("Index"));
}
return(View(vehicleModelViewModel));
}
public void GetAndSetDataCorrectly(int test)
{
// Arrange and Act
var viewModel = new VehicleModelViewModel()
{
Id = test
};
// Assert
Assert.AreEqual(test, viewModel.Id);
}
public async Task <HttpResponseMessage> PutVehicleModel(Guid id, VehicleModelViewModel vehicleModel)
{
if (ModelState.IsValid)
{
var vehicleModels = await _vehicleModelService.UpdateVehicleModel(Mapper.Map <VehicleModelDomainModel>(vehicleModel));
return(Request.CreateResponse(HttpStatusCode.OK, vehicleModel));
}
return(Request.CreateResponse(HttpStatusCode.InternalServerError, "error, can't update"));
}
//POST: api/models
public async Task <IHttpActionResult> Post([FromBody] VehicleModelViewModel model)
{
if (model == null)
{
return(BadRequest("Vehicle data not entered"));
}
var createdModelWithId = await Service.CreateModel(Mapper.Map <IVehicleModel>(model));
return(Created(Request.RequestUri + model.ToString(), Mapper.Map <VehicleModelViewModel>(createdModelWithId)));
}
public async Task <ActionResult> Create(VehicleModelViewModel vehicleModel)
{
if (ModelState.IsValid)
{
var mappedVehicleModel = Mapper.Map <VehicleModel>(vehicleModel);
await Service.AddVehicleModelAsync(mappedVehicleModel);
return(RedirectToAction(nameof(Index), new { id = vehicleModel.VehicleMakeId }));
}
return(View());
}
public void GetAndSetDataCorrectly(string test)
{
// Arrange and Act
var viewModel = new VehicleModelViewModel()
{
Name = test
};
// Assert
Assert.AreEqual(test, viewModel.Name);
}
//POST-Edit-AutoMapper
public async Task <IActionResult> EditPost(VehicleModelViewModel updatedViewModel) // provjeri trebas li uopce bit iu viewmodelu ovdje, ili samo ostavim sve da bude VehicleModel
{
if (ModelState.IsValid)
{
var updatedModel = mapper.Map <VehicleModel>(updatedViewModel); // tu mi mapira iz viewModela u vehicleModel
await vehicleModelService.UpdateModelAsync(updatedModel);
return(RedirectToAction("Index"));
}
return(View("Edit", updatedViewModel));
}
public async Task <IHttpActionResult> CreateVehicleModel(VehicleModelViewModel vehicleModelViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
VehicleModel vehicleModel = iMapper.Map <VehicleModel>(vehicleModelViewModel);
await _vehicleService.CreateVehicleModel(vehicleModel);
return(CreatedAtRoute("DefaultApi", new { id = vehicleModelViewModel.Id }, vehicleModelViewModel));
}
//POST-Create-AutoMapper
public async Task <IActionResult> CreatePost(VehicleModelViewModel newViewModel) // ovdje ubaci u funkciju veiwModel, onda (red ispod) mapiraj taj vm u model
{
if (ModelState.IsValid)
{
var newModel = mapper.Map <VehicleModel>(newViewModel); // ovo ce mapirati object iz VehicleModelViewModel u VehicleModel
await vehicleModelService.CreateModelAsync(newModel);
return(RedirectToAction("Index"));
}
return(View("Create", newViewModel));
}
public ActionResult Create([Bind(Include = "VehicleModelId,VehicleMakeId,Name,Abrv")] VehicleModelViewModel vehicleModelView)
{
if (ModelState.IsValid)
{
vehicleModelView.VehicleModelId = Guid.NewGuid();
vehicleService.CreateVehicleModel(vehicleModelView);
return(RedirectToAction("Index"));
}
ViewBag.VehicleMakeId = new SelectList(vehicleService.GetAllVehicleMakes(), "Id", "Name", vehicleModelView.VehicleMakeId);
return(View(vehicleModelView));
}
public async Task <IActionResult> DeleteVehicleModelAsync(VehicleModelViewModel vehicleModelViewModel)
{
try
{
await vehicleModelService.DeleteVehicleModelAsync(mapper.Map <IVehicleModelDTO>(vehicleModelViewModel));
return(RedirectToAction(nameof(GetVehicleModelsAsync)));
}
catch
{
return(View());
}
}
public async Task <ActionResult> Delete(int id)
{
VehicleModelViewModel model = new VehicleModelViewModel();
var vehicle = await vehicleModelService.GetByIdAsync(id);
if (vehicle == null)
{
return(HttpNotFound());
}
model = Mapper.Map <IVehicleModel, VehicleModelViewModel>(vehicle);
Mapper.AssertConfigurationIsValid();
return(View(model));
}
public async Task <ActionResult> Edit(VehicleModelViewModel model)
{
if (ModelState.IsValid)
{
var vehicle = Mapper.Map <VehicleModelViewModel, IVehicleModel>(model);
Mapper.AssertConfigurationIsValid();
await vehicleModelService.UpdateAsync(vehicle);
return(RedirectToAction("Index"));
}
return(View(model));
}
public async Task <IHttpActionResult> GetVehicleModelByID(int id)
{
IVehicleModel vehicleModel = await _vehicleModelService.GetVehicleModelByIDAsync(id);
if (vehicleModel == null)
{
return(NotFound());
}
VehicleModelViewModel vehicleModelViewModel = _mapper.Map <VehicleModelViewModel>(vehicleModel);
return(Ok(vehicleModelViewModel));
}
// GET: VehicleModel/Details/5
public ActionResult Details(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
VehicleModelViewModel vehicleModelVM = vehicleService.FindIdModel(id);
if (vehicleModelVM == null)
{
return(HttpNotFound());
}
return(View(vehicleModelVM));
}
public async Task <HttpResponseMessage> AddVehModel(VehicleModelViewModel AddObj)
{
try
{
AddObj.VehicleModelId = Guid.NewGuid();
var response = await VehicleModelService.AddAsync(Mapper.Map <IVehicleModelDomainModel>(AddObj));
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
public async Task <ActionResult> Create([Bind(Include = "Id,Name,Abrv,VehicleMakeID")] VehicleModel vehicleModel)
{
if (ModelState.IsValid)
{
await _modelService.InsertModel(vehicleModel);
return(RedirectToAction("Index"));
}
IEnumerable <VehicleMake> makes = await _makeService.GetMakes();
ViewBag.VehicleMakeID = new SelectList(makes, "Id", "Name", vehicleModel.VehicleMakeID);
VehicleModelViewModel viewModel = _mapper.Map <VehicleModelViewModel>(vehicleModel);
return(View(viewModel));
}
