public ActionResult <CommandReadDto> CreateCommand(CommandCreateDto commandCreateDto)
{
var commandModel = _mapper.Map <Command>(commandCreateDto);
var command = _repository.CreateCommand(commandModel);
return(CreatedAtRoute("GetCommand", new { id = command.Id.ToString() }, _mapper.Map <CommandReadDto>(command)));
}
public ActionResult <CammandReadDTO> CreateComand(CommandCreateDTO commandCreateDTO)
{
var command = _mapper.Map <Command>(commandCreateDTO);
_repo.CreateCommand(command);
return(Ok(command));
}
public ActionResult <Command> CreateCommand(Command command)
{
_repository.CreateCommand(command);
_repository.SaveChanges();
return(CreatedAtRoute(nameof(GetCommandById), new { Id = command.Id }, command));
}
public ActionResult <CommandReadDto> PostCommand(CommandCreateDto item)
{
var commandModel = _mapper.Map <Command>(item);
_repository.CreateCommand(commandModel);
if (_repository.SaveChanges())
{
var commandReadDto = _mapper.Map <CommandReadDto>(commandModel);
return(Ok(new {
data = commandReadDto,
status = true
}));
// Return HTTP Code 201
// return CreatedAtRoute(nameof(GetCommandById), new {Id = commandReadDto.Id}, commandReadDto);
}
else
{
return(NotFound(new {
message = "Não foi possível salvar o registro!",
status = false
}));
}
}
public ActionResult <CommandRest> CreateCommand(CommandParams command)
{
var commandModel = _mapper.Map <Command>(command);
_repository.CreateCommand(commandModel);
return(Ok(_mapper.Map <CommandRest>(commandModel)));
}
public ActionResult <CommandReadDto> CreateCommand([FromBody] CommandCreateDto commandCreateDto)
{
var commandModel = _mapper.Map <Command>(commandCreateDto);
_repoCommanderRepo.CreateCommand(commandModel);
return(CreatedAtRoute(nameof(GetCommandsById), new { Id = commandModel.Id }, commandModel));
}
public ActionResult <CommandDto> CreateCommand(CommandDto commandDto)
{
var commandModel = _mapper.Map <Command>(commandDto);
_repository.CreateCommand(commandModel);
_repository.SaveChanges();
return(CreatedAtRoute(nameof(GetCommandById), new { commandDto.Id }, commandDto));
}
public ActionResult <CommandReadDto> CreateCommand(CommandCreateDto commandCreateDto)
{
var command = _mapper.Map <Command>(commandCreateDto);
_commanderRepo.CreateCommand(command);
_commanderRepo.SaveChanges();
var commandReadDto = _mapper.Map <CommandReadDto>(command);
return(CreatedAtAction(nameof(GetCommandById), new { id = command.Id }, commandReadDto));
}
public ActionResult <CommandReadDTO> CreateCommand(CommandCreateDTO pCommand)
{
var commandModel = _mapper.Map <Command>(pCommand);
_context.CreateCommand(commandModel);
var commandReadDTO = _mapper.Map <CommandReadDTO>(commandModel);
return(CreatedAtRoute(nameof(GetCommandById), new { Id = commandReadDTO.Id }, commandReadDTO));
}
public async Task <ActionResult <CommandReadDto> > CreateCommand(CommandWriteDto command, CancellationToken cancellationToken)
{
var commandModel = _mapper.Map <Command>(command);
await _repository.CreateCommand(commandModel, cancellationToken).ConfigureAwait(false);
var commandResult = _mapper.Map <CommandReadDto>(command);
//CreatedAtRoute returns URI of created value. ie api/commands/{id}
return(CreatedAtRoute(nameof(GetCommandById), new { Id = commandResult.Id }, commandResult));
}
public ActionResult <CommanderReadDto> CreateCommand(CommanderCreateDto commanderCreateDto)
{
var commandModel = _mapper.Map <Command>(commanderCreateDto);
_repo.CreateCommand(commandModel);
_repo.SaveChanges();
var commandReadDto = _mapper.Map <CommanderReadDto>(commandModel);
return(CreatedAtRoute(nameof(GetCommandById), new { Id = commandReadDto.Id }, commanderCreateDto));
}
public ActionResult <CommandReadDTO> createCommand(CommandCreateDTO commandCreateDTO)
{
Command commandModel = _mapper.Map <Command>(commandCreateDTO);
_repository.CreateCommand(commandModel);
_repository.saveChanges();
CommandReadDTO commandReadDto = _mapper.Map <CommandReadDTO>(commandModel);
return(CreatedAtRoute(nameof(getCommandByID), new{ Id = commandReadDto.Id }, commandReadDto));
}
public ActionResult <CommandReadDto> CreateCommand(CommandCreateDto cmd)
{
var commandModel = _mapper.Map <Command>(cmd);
_repository.CreateCommand(commandModel);
_repository.SaveChanges();
var commanReadModel = _mapper.Map <CommandReadDto>(commandModel);
return(CreatedAtRoute(nameof(GetCommandById), new { Id = commanReadModel.Id }, cmd));
}
public ActionResult <CommandCreateDTO> CreateCommand(CommandCreateDTO commandCreateDTO)
{
var commandModel = _mapper.Map <Command>(commandCreateDTO);
_repository.CreateCommand(commandModel);
_repository.SaveChanges();
var commandReadDTO = _mapper.Map <CommandReadDTO>(commandModel);
return(CreatedAtRoute(nameof(GetCommandById), new { id = commandReadDTO.Id }, commandReadDTO)); //name of the route used to create, the data used to create, the model used to create
}
[HttpPost] // Post api/command
public ActionResult <CommandCreateDTO> CreateCommand(CommandCreateDTO commandCreateDTO)
{
Command commandModel = _mapper.Map <Command>(commandCreateDTO);
_repo.CreateCommand(commandModel);
_repo.SaveChanges();
CommandReadDTO commandReadDTO = _mapper.Map <CommandReadDTO>(commandModel);
return(CreatedAtRoute("GetCommandById", new { commandReadDTO.Id }, commandReadDTO)); // Using HttpGet route name
}
public ActionResult <CommandReadDto> CreateCommand(CommandCreateDto commandCreateDto)
{
var commandModel = _mapper.Map <Command>(commandCreateDto);
_repository.CreateCommand(commandModel);
_repository.SaveChanges();
var commandReadDto = _mapper.Map <CommandReadDto>(commandModel);
return(Ok(commandReadDto));
}
public ActionResult <CommandReadDTO> CreateCommand(CommandCreateDTO commandCreateDTO)
{
var commandModel = _mapper.Map <Command>(commandCreateDTO);
_repository.CreateCommand(commandModel);
_repository.SaveChanges();
var commandReadDTO = _mapper.Map <CommandReadDTO>(commandModel);
// return Ok(commandReadDTO);
return(CreatedAtRoute(nameof(GetCommandById), new { Id = commandReadDTO.Id }, commandReadDTO));
}
public ActionResult <CommandReadDto> CreateCommand(CommandCreateDto commandCreateDto)
{
var commandModel = _mapper.Map <Command>(commandCreateDto); //Map from dto to model
_repository.CreateCommand(commandModel); //First you have to map the DTO and then you call the DB create method
_repository.SaveChanges(); //Commit your changes
var commandReadDto = _mapper.Map <CommandReadDto>(commandModel); //Map it back to DTO to respond to client
return(CreatedAtRoute(nameof(GetCommandById), new { Id = commandReadDto.Id }, commandReadDto)); //It finds the created object in order to manipulate the reponse code
}
public ActionResult <CommandReadDto> CreateCommand([FromBody] CommandCreateDto cmd)
{
Command commandModel = _mapper.Map <Command>(cmd);
_repo.CreateCommand(commandModel);
_repo.SaveChanges();
CommandReadDto commandReadDto = _mapper.Map <CommandReadDto>(commandModel);
return(CreatedAtRoute(nameof(GetCommandById), new { commandReadDto.Id }, commandReadDto));
}
public ActionResult <CommandReadDto> CreateCommand(CommandCreateDto commandCreateDto)
{
var commandModel = _mapper.Map <Command>(commandCreateDto);
_repository.CreateCommand(commandModel);
var commandReadDto = _mapper.Map <CommandReadDto>(commandModel);
return(CreatedAtRoute(nameof(GetCommandById), new { Id = commandReadDto.Id }, commandReadDto));
//return Ok(commandReadDto);
}
public ActionResult <CommandReadDto> CreateCommand(CommandCreateDto cmd)
{
Command command = _mapper.Map <Command>(cmd);
_repository.CreateCommand(command);
_repository.SaveChanges();
var readCmd = _mapper.Map <CommandReadDto>(command);
return(CreatedAtRoute(nameof(GetCommandById), new { Id = readCmd.Id }, readCmd));
}
public ActionResult <CommandReadDto> CreateCommand(CommandCreateDto command)
{
var commandToCreate = _mapper.Map <Command>(command);
_repository.CreateCommand(commandToCreate);
_repository.SaveChanges();
var commandReadDto = _mapper.Map <CommandReadDto>(commandToCreate);
var result = CreatedAtRoute(nameof(GetCommandById), new { Id = commandReadDto.Id }, commandReadDto);
return(result);
}
public async Task <ActionResult <CommandReadDto> > CreateCommandAsync(CommandCreateDto commandCreateDto)
{
var commandModel = _mapper.Map <Command>(commandCreateDto);
_repository.CreateCommand(commandModel);
_repository.SaveChanges();
var commandReadDto = _mapper.Map <CommandReadDto>(commandModel);
return(CreatedAtRoute(nameof(GetCommandByID), new { ID = commandReadDto.id }, commandReadDto));
//return Ok(commandReadDto);
}
public ActionResult <CommandCreateDto> CreateCommand(CommandCreateDto commandCreateDto)
{
var commanModel = _mapper.Map <Command>(commandCreateDto);
_repository.CreateCommand(commanModel);
_repository.SaveChanges();
var commandReadDto = _mapper.Map <CommandReadDto>(commanModel);
return(CreatedAtRoute(nameof(GetCommandById), new { Id = commandReadDto.Id }, commandReadDto)); // this was used to avoid passing back or geting the instance of our model that is created. Rather we should display our commandReadDTO
//return Ok(commandReadDto);
}
public ActionResult<CommandReadDto> CreateCommand(CommandCreateDto commandCreateDto) //It is CommandReadDto because as a respond of POST method is exactly that dto
{
var model = _mapper.Map<Command>(commandCreateDto);
_repository.CreateCommand(model);
_repository.SaveChanges();
var commandReadDto = _mapper.Map<CommandReadDto>(model); //It;s made for return a response to client as a CommandReadDto to maintain contract - response as a location
return CreatedAtRoute(nameof(GetCommandById), new { Id = commandReadDto.Id }, commandReadDto); /* https://docs.microsoft.com/en-us/dotnet/api/system.web.http.apicontroller.createdatroute?view=aspnetcore-2.2 */
//return Ok(commandReadDto);
}
public ActionResult <CommandRead> CreateCommand(CommandCreate commandCreate)
{
var commandModel = _mapper.Map <Command>(commandCreate);
_repository.CreateCommand(commandModel);
_repository.SaveChanges();
var CommandReadDto = _mapper.Map <CommandRead>(commandModel);
return(CreatedAtRoute(nameof(GetCommandById), new { Id = CommandReadDto.Id }, CommandReadDto));
// return Ok(CommandReadDto);
}
public ActionResult <CommandReadDTO> CreateCommand(CommandWriteDTO cmd)
{
var commandModel = _mapper.Map <Command>(cmd);
_command_repo.CreateCommand(commandModel);
_command_repo.SaveChanges(); // synchrounous save
var commandReadDTO = _mapper.Map <CommandReadDTO>(commandModel);
return(CreatedAtRoute(nameof(GetCommandById), new { Id = commandReadDTO.Id }, commandReadDTO));
}
public ActionResult <CommandReadDto> CreateCommand(CommandCreateDto command)
{
var writeCommand = _mapper.Map <Command>(command);
_commanderRepo.CreateCommand(writeCommand);
_commanderRepo.SaveChanges();
var readCommand = _mapper.Map <CommandReadDto>(writeCommand);
return(CreatedAtRoute(nameof(GetCommandById), new { Id = readCommand.Id }, readCommand));
}
public ActionResult <CommandReadDto> CreateCommand(CommandCreateDto cmd)
{
var commandItem = _mapper.Map <Command>(cmd);
_repository.CreateCommand(commandItem);
if (_repository.dbSaveChanges())
{
var cmdReadDto = _mapper.Map <CommandReadDto>(commandItem);
return(CreatedAtRoute(nameof(GetCommandById), new { id = cmdReadDto.id }, cmdReadDto));
}
return(NotFound());
}
//cogemos como input un CommandCreateDto y se devuelve como output un CommandReadDto.
//queremos coger lo que haya en el body de la request y convertirlo en un modelo que podamos poner en nuestro repositorio, para eso usaremos Automapper
public ActionResult <CommandReadDto> CreateCommand(CommandCreateDto commandCreateDto)
{
var commandModel = _mapper.Map <Command>(commandCreateDto);//queremos hace Map a Command y la source es commandCreateDto
_repository.CreateCommand(commandModel);
_repository.SaveChanges();
var commandReadDto = _mapper.Map <CommandReadDto>(commandModel);
//para crear un 201 Created, buscar mas info de CreatedAtRoute method para mas info
return(CreatedAtRoute(nameof(GetCommandById), new { Id = commandReadDto.Id }, commandReadDto));
}
