public ActionResult <CommandUpdateDTO> PutMethodById(int id, CommandUpdateDTO newcmd) { var commandsItem = _repository.GetCommandById(id); if (commandsItem != null) { var newDTO = _mapper.Map <Command>(newcmd); _repository.UpdateCommand(id, newDTO); if (_repository.SaveChanges()) { // return Ok(); var returnObj = _mapper.Map <CommandReadDTO>(newDTO); returnObj.Id = id; //return Ok(returnObj); return(CreatedAtRoute(nameof(GetCommandById), new { Id = returnObj.Id }, returnObj)); } throw new System.ArgumentException("Save Failed", "original"); } /*Option 2: * _mapper.Map(newcmd, commandsItem); * _repository.UpdateCommand(commandsItem); * _repository.SaveChanges(); */ return(NotFound()); }
public ActionResult partialCommandUpdate(int id, JsonPatchDocument <CommandUpdateDTO> patchDocument) { Command commandFromRepo = _repository.GetCommandByID(id); if (commandFromRepo == null) { return(NotFound()); } CommandUpdateDTO commandToPatch = _mapper.Map <CommandUpdateDTO>(commandFromRepo); patchDocument.ApplyTo(commandToPatch, ModelState); if (!TryValidateModel(commandToPatch)) { return(ValidationProblem(ModelState)); } _mapper.Map(commandToPatch, commandFromRepo); _repository.UpdateCommand(commandFromRepo); _repository.saveChanges(); return(NoContent()); }
public ActionResult UpdateCommand(int id, CommandUpdateDTO commandUpdateDTO) { var commandModelFromRepo = _repository.GetCommandById(id); if (commandModelFromRepo == null) { return(NotFound()); } _mapper.Map(commandUpdateDTO, commandModelFromRepo); _repository.UpdateCommand(commandModelFromRepo); _repository.SaveChanges(); return(NoContent()); }
public ActionResult UpdateCommand(int id, CommandUpdateDTO commandUpdateDTO) { Command foundCommand = repository.GetCommandById(id); if (foundCommand == null) { return(NotFound()); } mapper.Map(commandUpdateDTO, foundCommand); repository.UpdateCommand(foundCommand); repository.SaveChanges(); return(NoContent()); }
public ActionResult UpdateCommand(int id, CommandUpdateDTO commandUpdateDTO) { var commandItem = Repository.GetCommandBy(id); if (commandItem == null) { return(NotFound()); } var commandModel = Mapper.Map(commandUpdateDTO, commandItem); Repository.UpdateCommand(commandItem); Repository.SaveChanges(); return(NoContent()); }
public ActionResult <CommandReadDTO> UpdateCommand(int id, CommandUpdateDTO updateCommand) { var command = _repo.GetCommandById(id); if (command == null) { return(NotFound()); } _mapper.Map(updateCommand, command); _repo.UpdateCommand(command); _repo.SaveChanges(); return(Ok(_mapper.Map <CommandReadDTO>(command))); }
public ActionResult UpdateCommand(int id, CommandUpdateDTO commandUpdate) { var commandModelFromRepo = _ICommand.GetCommandById(id); if (commandModelFromRepo == null) { return(NotFound()); // 404 Not found } _mapper.Map(commandUpdate, commandModelFromRepo); _ICommand.UpdateCommand(commandModelFromRepo); _ICommand.SaveChanges(); return(NoContent()); // 204 No Content Success }
public ActionResult UpdateCommand(int id, CommandUpdateDTO command) { var commandFromRepo = _repo.GetCommandById(id); if (commandFromRepo == null) { return(NotFound()); } // map source, destination _mapper.Map(command, commandFromRepo); _repo.UpdateCommand(commandFromRepo); _repo.SaveChanges(); return(NoContent()); }
public ActionResult UpdateCommand(int id, CommandUpdateDTO commandUpdateDTO) { var commandModelFromRepo = _repository.GetCommandById(id); if (commandModelFromRepo == null) { return(NotFound()); } _mapper.Map(commandUpdateDTO, commandModelFromRepo); _repository.UpdateCommand(commandModelFromRepo); // not doing anthing currently, for future if EF is swapped for somethign else _repository.SaveChanges(); return(NoContent()); }
[HttpPut("{id}")] //Put api/command/{id} public ActionResult <CommandUpdateDTO> UpdateCommand(int id, CommandUpdateDTO commandUpdateDTO) { // Checks to see if command is found Command commandModelRepo = _repo.GetCommandById(id); if (commandModelRepo == null) { return(NotFound()); } _mapper.Map(commandUpdateDTO, commandModelRepo); _repo.UpdateCommand(commandModelRepo); _repo.SaveChanges(); return(NoContent()); }
public ActionResult updateCommand(int id, CommandUpdateDTO commandUpdate) { Command commandFromRepo = _repository.GetCommandByID(id); if (commandFromRepo == null) { return(NotFound()); } _mapper.Map(commandUpdate, commandFromRepo); _repository.UpdateCommand(commandFromRepo); _repository.saveChanges(); return(NoContent()); }
public ActionResult <CommandReadDTO> UpdateCommand(int id, CommandUpdateDTO commandUpdateDTO) { var commandModelFromRepo = _repository.GetCommandById(id); if (commandModelFromRepo == null) { return(NotFound()); } _mapper.Map(commandUpdateDTO, commandModelFromRepo); //updates commandModelFromRepo with content dial 1st param _repository.UpdateCommand(commandModelFromRepo); _repository.SaveChanges(); return(NoContent()); // Response : OK }
public async Task <ActionResult> UpdateCommand(int id, CommandUpdateDTO cmdUpdateDTO) { var commandToUpdate = await _db.GetCommandByIdAsync(id); if (commandToUpdate == null) { return(NotFound()); } //takes care of updating- hence empty interface implementation _mapper.Map(cmdUpdateDTO, commandToUpdate); //just in case later in future you need more specific update implementation await _db.UpdateCommandAsync(commandToUpdate); await _db.SaveChangesAsync(); return(NoContent()); }
public ActionResult UpdateCommand(int id, CommandUpdateDTO pCommand) { var commandModel = _context.GetCommandById(id); if (commandModel == null) { return(NotFound()); } _mapper.Map(pCommand, commandModel); _context.UpdateCommand(commandModel); _context.SaveChanges(); var commandReadDTO = _mapper.Map <CommandReadDTO>(commandModel); return(CreatedAtRoute(nameof(GetCommandById), new { Id = commandReadDTO.Id }, commandReadDTO)); }
public ActionResult <CommandReadDTO> UpdateCommand(int id, CommandUpdateDTO commandUpdateDTO) { var commandModelIFromRepo = _repository.GetCommandById(id); if (commandModelIFromRepo == null) { return(NotFound()); } _mapper.Map(commandUpdateDTO, commandModelIFromRepo); _repository.UpdateCommand(commandModelIFromRepo); _repository.SaveChanges(); return(NoContent()); //return CreatedAtRoute(nameof(GetCommandById), new { Id = commandReadDTO.Id }, commandReadDTO); //return Ok(commandReadDTO); }
[HttpPatch("{id}")] //Patch api/commands/{id} public ActionResult PartialCommandUpdate(int id, JsonPatchDocument <CommandUpdateDTO> jsonPatchDoc) { Command commandModelRepo = _repo.GetCommandById(id); if (commandModelRepo == null) { return(NotFound()); } CommandUpdateDTO commandToPatch = _mapper.Map <CommandUpdateDTO>(commandModelRepo); // new C.U.DTO to our command repo and into commandPatch jsonPatchDoc.ApplyTo(commandToPatch, ModelState); if (!TryValidateModel(commandToPatch)) { return(ValidationProblem(ModelState)); // Validation } _mapper.Map(commandToPatch, commandModelRepo); // update command patch to our repo _repo.UpdateCommand(commandModelRepo); _repo.SaveChanges(); return(NoContent()); }
public ActionResult <CommandReadDTO> Put(Guid id, [FromBody] CommandUpdateDTO updateCommand) { if (updateCommand == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(UnprocessableEntity()); } var commandDb = repositoryWrapper.Command.GetByCondition(c => c.Id.Equals(id), false).FirstOrDefault(); if (commandDb == null) { return(NotFound()); } mapper.Map(updateCommand, commandDb); repositoryWrapper.Command.Update(commandDb); var result = repositoryWrapper.Save(); return(NoContent()); }
public ActionResult PartialUpdateCommand(int id, JsonPatchDocument <CommandUpdateDTO> patchDocument) { Command foundCommand = repository.GetCommandById(id); if (foundCommand == null) { return(NotFound()); } CommandUpdateDTO commandToPatch = mapper.Map <CommandUpdateDTO>(foundCommand); patchDocument.ApplyTo(commandToPatch, ModelState); if (TryValidateModel(patchDocument)) { return(ValidationProblem(ModelState)); } mapper.Map(commandToPatch, foundCommand); repository.UpdateCommand(foundCommand); repository.SaveChanges(); return(NoContent()); }
public async Task <IActionResult> PutCommand(int id, CommandUpdateDTO commandUpdateDTO) { //if (id != command.ID) //{ // return BadRequest(); //} var command = _context.Commands.FirstOrDefault(c => c.ID == id); if (command == null) { return(NotFound()); } _mapper.Map(commandUpdateDTO, command); _context.Entry(command).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CommandExists(id)) { return(NotFound()); } else { throw; } } return(CreatedAtAction(nameof(GetCommand), new { command.ID }, command)); }