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)
{
var commandModelFromRepo = _repository.GetCommandById(id);
if (commandModelFromRepo == null)
{
return(NotFound());
}
_mapper.Map(commandUpdateDto, commandModelFromRepo);
// with entity framework this is not required, but is a good practice,
// because, maybe another implementation of the ICommanderRepo needs it
_repository.UpdateCommand(commandModelFromRepo);
_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); //!!!Different syntax, because both of these classes has data (existing model)
_repository.UpdateCommand(commandModelFromRepo);
_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); //another form of mapping
_repository.UpdateCommand(commandModelFromRepo); //just kept in case you swap out the repo implementation in future
_repository.SaveChanges();
return(NoContent());
}
public ActionResult UpdateCommand(int id, CommandUpdateDto commandUpdateDto)
{
var commandModelFromRepo = _repository.GetCommandById(id);
if (commandModelFromRepo == null)
{
return(NotFound()); //returns 404 Not Found if command id does not exist
}
_mapper.Map(commandUpdateDto, commandModelFromRepo);
_repository.UpdateCommand(commandModelFromRepo);
_repository.SaveChanges(); //this makes sure that the command created gets saved in our database
return(NoContent()); //returns 204 response
}
public ActionResult UpdateCommand(int id, CommandUpdateDto commandUpdateDto)
{
var commandModelFromRepo = _repository.GetCommandById(id);
if (commandModelFromRepo == null)
{
return(NotFound());
}
_mapper.Map(commandUpdateDto, commandModelFromRepo);
_repository.UpdateCommand(commandModelFromRepo); //doesn't do anything but if implementation changes it is already here
_repository.SaveChanges();
return(NoContent());
}
public ActionResult UpdateCommand(int id, CommandUpdateDto commandUpdateDto)
{
var commandFromRepo = _commanderRepo.GetCommandById(id);
if (commandFromRepo == null)
{
return(NotFound());
}
_mapper.Map(commandUpdateDto, commandFromRepo);// this syntax because both has data present, previously only source data was available
//this already upadated our model so no needed implementation in SqlCommanderRepo
_commanderRepo.UpdateCommand(commandFromRepo);
_commanderRepo.SaveChanges();
return(NoContent());
}
public ActionResult UpdateCommand(int id, CommandUpdateDto commandUpdateDto)
{
var commandModelFromRepo = _repository.GetCommandById(id);
if (commandModelFromRepo == null)
{
return(NotFound());
}
//Updatedto'dan command'e çevirecek syntax farklı commandModelFromRepo güncellenecek source'a göre
_mapper.Map(commandUpdateDto, commandModelFromRepo);
_repository.UpdateCommand(commandModelFromRepo);
_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); //REDUNDANT, empty method - to keep in compliance with REST standard
_repository.SaveChanges();
return(NoContent());
}
public ActionResult UpdateCommand(int Id, CommandUpdateDto ObjCmdcreateDto)
{
var objUpdatecommandById = _repository.GetCommandById(Id);
if (objUpdatecommandById == null)
{
return(NotFound());
}
_mapper.Map(ObjCmdcreateDto, objUpdatecommandById);
_repository.UpdateCommand(objUpdatecommandById);
_repository.SaveChanges();
return(NoContent());
}
public ActionResult UpdateCommand(int id, CommandUpdateDto cmd)
{
Command cmdModelFromRepo = _repository.GetCommandById(id);
if (cmdModelFromRepo == null)
{
return(NotFound());
}
// Updates original object, which syncs with DB
_mapper.Map(cmd, cmdModelFromRepo);
// This should do nothing in most implementations, but might be used by users
_repository.UpdateCommand(cmdModelFromRepo);
_repository.SaveChanges();
return(NoContent());
}
public ActionResult UpdateCommand(int id, CommandUpdateDto commandUpdateDto)
{
var commandModelFromRepo = _repository.GetCommandById(id); // cherche l'objet dans la bdd
if (commandModelFromRepo == null)
{
return(NotFound()); // si il n'existe pas on quitte et envoie 404
}
// met commandUpdateDto dans commandModelFromRepo
_mapper.Map(commandUpdateDto, commandModelFromRepo);
_repository.UpdateCommand(commandModelFromRepo); // update l'objet
_repository.SaveChanges(); // sauvegarde l'état de l'objet dans la bdd
return(NoContent());
}
public ActionResult UpdateCommad(int id, CommandUpdateDto commandUpdateDto)
{
var command = _repository.GetCommandById(id);
if (command == null)
{
return(NotFound());
}
_mapper.Map(commandUpdateDto, command);
//_repository.UpdateCommand(command); // Useless in this case
_repository.SaveChanges();
return(NoContent());
}
public ActionResult UpdateCommand(int id, CommandUpdateDto commandUpdateDto)
{
var commandModelFromRepo = _Repository.GetCommandById(id);
if (commandModelFromRepo is null)
{
return(NotFound($"No command found with id {id}"));
}
_Mapper.Map(commandUpdateDto, commandModelFromRepo);
_Repository.UpdateCommand(commandModelFromRepo);
_Repository.SaveChanges();
return(NoContent());
}
public ActionResult UpdateCommand(int Id, CommandUpdateDto commandUpdateDto)
{
var commandModelFromRepo = _repository.GetCommandById(Id);
if (commandModelFromRepo == null)
{
return(NotFound());
}
//map from updateDto to model // mapping is just exist but we don't do any thing with it right now
_mapper.Map(commandUpdateDto, commandModelFromRepo);
_repository.UpdateCommand(commandModelFromRepo);
_repository.SaveChanges();
return(NoContent());
}
public ActionResult UpdateCommand(int id, CommandUpdateDto commandUpdateDto)
{
var commandModelFromRepo = _repository.GetCommandById(id);
if (commandModelFromRepo is null)
{
return(NotFound());
}
_mapper.Map(commandUpdateDto, commandModelFromRepo);
_repository.UpdateCommand(commandModelFromRepo); // <- useless, but here in case you change your implementation and
// it needs it, its there.
_repository.SaveChanges();
return(NoContent());
}
public async Task <ActionResult> UpdateCommand(int id, CommandUpdateDto commandUpdateDto)
{
var commandModelFromRepo = await Task.Run(() => _commandAPIRepo.GetCommandById(id));
if (commandModelFromRepo == null)
{
return(NotFound());
}
// Mapper will mutate commandModelFromRepo in db context
_mapper.Map(commandUpdateDto, commandModelFromRepo);
// After muttation, we need to save changes to db
await Task.Run(() => _commandAPIRepo.SaveChanges());
return(NoContent());
}
public ActionResult <CommandUpdateDto> UpdateCommand(int id, CommandUpdateDto commandUpdateDto)
{
var commandModelFromRepo = _repository.GetCommandById(id);
if (commandModelFromRepo == null)
{
return(NotFound());
}
//It automatically updates the model with the commandUpdateDto
_mapper.Map(commandUpdateDto, commandModelFromRepo);
//In our case with sql we don't need to do anything here but either way we call it
//in case we change the database the update will work the same way
_repository.UpdateCommand(commandModelFromRepo);
_repository.SaveChanges();
return(NoContent());
}
public ActionResult UpdateCommand(int id, CommandUpdateDto commandUpdateDto)
{
// check that the resource to be updated exist
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 commandModelFromRepo = _repo.GetCommandById(id);
if (commandModelFromRepo == null)
{
return(NotFound());
}
_mapper.Map(commandUpdateDto, commandModelFromRepo);
// Ookal doet deze methode niets in ONZE implementatie; stel je hebt een andere repo met wél een implementatie. Dan staat deze hier al.
// Die zal door het gebruik van de ICommanderRepo deze ook moeten implementeren, dus staat deze hier al.
_repo.UpdateCommand(commandModelFromRepo);
_repo.SaveChanges();
return(NoContent());
}
public async Task <ActionResult> UpdateCommand(int id, CommandUpdateDto commandToUpdate)
{
var cmdModelFromRepo = await _commandsRepo.GetCommandByIdAsync(id);
if (cmdModelFromRepo == null)
{
return(NotFound());
}
_mapper.Map(commandToUpdate, cmdModelFromRepo);
//_apiRepo.UpdateCommand(cmdModelFromRepo);
await _commandsRepo.SaveCommandsChanges();
// Return updated Resource
return(Ok(_mapper.Map <CommandReadDto>(cmdModelFromRepo)));
}
public ActionResult UpdateCommand(int id, CommandUpdateDto updateDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var commandFromRepo = _repository.GetCommandById(id);
if (commandFromRepo == null)
{
return(NotFound());
}
var commandModel = _mapper.Map(updateDto, commandFromRepo);
_repository.UpdateCommand(commandFromRepo);
_repository.SaveChanges();
return(NoContent());
}
public ActionResult <Command> UpdateCommand(int id, CommandUpdateDto commandUpdateDto)
{
var command = _respository.GetCommandById(id);
if (command == null)
{
return(NotFound());
}
_mapper.Map(commandUpdateDto, command);
_respository.UpdateCommand(command);
_respository.SaveChanges();
var commandReadDto = _mapper.Map <CommandReadDto>(command);
return(CreatedAtRoute(nameof(GetCommand), new { Id = commandReadDto.Id }, commandReadDto));
}
public ActionResult UpdateCommand(int id, CommandUpdateDto commandUpdateDto)
{
var commandModelFromRepo = _repository.GetCommandById(id);
if (commandModelFromRepo == null)
{
return(NotFound());
}
_mapper.Map(commandUpdateDto, commandModelFromRepo);
// does nothing here but left out incase of future i change to EF framework that requires it
_repository.UpdateCommand(commandModelFromRepo);
_repository.SaveChanges();
return(NoContent());
}
public ActionResult <CommandReadDto> UpdateCommand(int id, CommandUpdateDto cmd)
{
var commandModelFromRepo = _repoistory.GetCommandById(id);
if (commandModelFromRepo == null)
{
return(NotFound());
}
_mapper.Map(cmd, commandModelFromRepo);
_repoistory.UpdateCommand(commandModelFromRepo);
var commandRead = _mapper.Map <CommandReadDto>(commandModelFromRepo);
return(Ok(
commandRead
));
}
public ActionResult UpdateCommand(int id, CommandUpdateDto commandUpdateDto)
{
//Busca no Command o ID correspondente
var commandModelFromRepo = _repository.GetCommandById(id);
if (commandModelFromRepo == null)
{
return(NotFound());
}
_mapper.Map(commandUpdateDto, commandModelFromRepo); //Merge current|previous
_repository.UpdateCommand(commandModelFromRepo);
_repository.SaveChanges();
return(NoContent());
}
public ActionResult UpdateCommand(int id, [FromForm] CommandUpdateDto commandUpdateDto)
{
var commandFromRepo = _repository.GetCommandById(id);
//validations
if (commandFromRepo == null)
{
return(NotFound());
}
_mapper.Map(commandUpdateDto, commandFromRepo);
_repository.UpdateCommand(commandFromRepo);//Good practice
_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);
//EF doesn't actually require this, this is a good practice
_repository.SaveChanges();
return(NoContent());
}
public ActionResult <CommandReadDto> EditCommand(int id, CommandUpdateDto commandUpdateDto)
{
if (commandUpdateDto.Id != id)
{
return(NotFound());
}
var command = _mapper.Map <Command>(commandUpdateDto);
_repo.UpdateCommand(command);
if (_repo.saveChanges())
{
//var commandReadDto = _mapper.Map<CommandReadDto>(command);
return(NoContent());
}
return(BadRequest());
}
public ActionResult <CommandReadDto> Update(int id, CommandUpdateDto dto)
{
if (id == null || dto == null)
{
throw new ArgumentNullException();
}
var commandResult = _repository.GetCommandById(id);
if (commandResult == null)
{
return(NotFound());
}
_mapper.Map(dto, commandResult);
_repository.Update(commandResult);
_repository.SaveChanges();
return(NoContent());
}
