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)); }