public async Task <IActionResult> Edit(int?id)
{
if (id is null)
{
return(NotFound());
}
try
{
var game = await Mediator.Send(new GetGameByIdQuery { Id = id.Value });
var updateGameCommand = new UpdateGameCommand
{
Name = game.Name,
Description = game.Description,
Id = game.Id,
Price = game.Price,
SelectedCategories = (await Mediator.Send(
new GetAllGameCategoriesByGameIdQuery {
Id = game.Id
}))
.Select(x => x.CategoryId).ToList(),
AllCategories = await Mediator.Send(new GetAllCategoriesQuery())
};
return(View(updateGameCommand));
}
catch (NotFoundException)
{
return(NotFound());
}
}
public async Task ShouldUpdateGame()
{
GenerateMock();
var gameMock = new Mock <Game>();
gameMock.Setup(x => x.Update(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <string>(), It.IsAny <byte[]>()));
_gameRepositoryMock
.Setup(x => x.FindAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(gameMock.Object);
_gameRepositoryMock.Setup(x => x.Update(It.IsAny <Game>()));
_gameRepositoryMock.Setup(x => x.UnitOfWork.SaveAsync(It.IsAny <CancellationToken>()));
var handler = GetHandler();
var ver = new byte[] { 0x02 };
var command = new UpdateGameCommand(Guid.NewGuid(), "name", 2018, "platform", ver);
await handler.Handle(command, default);
gameMock.Verify(x => x.Update(
It.Is <string>(f => f.Equals("name")),
It.Is <int>(f => f.Equals(2018)),
It.Is <string>(f => f.Equals("platform")),
It.Is <byte[]>(f => f.Equals(ver))
));
_gameRepositoryMock.Verify(x => x.Update(It.Is <Game>(f => f.Equals(gameMock.Object))));
_gameRepositoryMock.Verify(x => x.UnitOfWork.SaveAsync(It.IsAny <CancellationToken>()));
}
public async Task <ActionResult> Edit(int id, [FromForm] UpdateGameCommand updateGameCommand)
{
if (id != updateGameCommand.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await Mediator.Send(updateGameCommand);
TempData["message"] =
$"Game \"{updateGameCommand.Name}\" has been updated.";
return(RedirectToAction(nameof(Index)));
}
catch (NotFoundException)
{
return(NotFound());
}
}
return(RedirectToAction(nameof(Index)));
}
public Task <bool> Handle(UpdateGameCommand command, CancellationToken cancellationToken)
{
if (!command.IsValid())
{
NotifyValidationErrors(command);
return(Task.FromResult(false));
}
var game = new Game(command.Id, command.Name, command.Description);
var gameCadastrado = gameReadRepository.GetByIdAsync(game.Id).Result;
if (gameCadastrado != null)
{
mediator.RaiseEventAsync(new DomainNotification(command.MessageType, "Essa jogo já está cadastrado na base de dados!"));
return(Task.FromResult(false));
}
gameWriteRepository.Update(game);
if (Commit())
{
mediator.RaiseEventAsync(new UpdateGameEvent(game.Id, game.Name, game.Description));
}
return(Task.FromResult(true));
}
public async Task <bool> Handle(UpdateGameCommand request, CancellationToken cancellationToken)
{
if (!request.IsValid())
{
NotifyValidationErrors(request);
return(false);
}
else if (!_gameRepository.IsExistGame(request.Id))
{
await _Bus.RaiseEvent(new DomainNotification(request.MessageType,
"Could not update game. The informed Id game does not exist"));
return(false);
}
else
{
var game = await _gameRepository.GetById(request.Id);
_Mapper.Map <UpdateGameCommand, Game>(request, game);
_gameRepository.Update(game);
return(Commit());
}
}
public async Task <IActionResult> Update(int id, UpdateGameCommand command)
{
if (id != command.Id)
{
return(BadRequest());
}
return(Ok(await Mediator.Send(command)));
}
public void Handle(UpdateGameCommand Message)
{
if (Message != null)
{
var game = _mapper.Map <Game>(Message);
_gameRepository.Update(game);
}
}
public async Task ExecuteAsync(GameUpdatedCommand command)
{
_logger.LogInformation(
$"{nameof(GameUpdatedCommand)} has been triggered with parameter {command.ToJsonString()}");
UpdateGameCommand updateGameCommand = _mapper.Map <UpdateGameCommand>(command);
await _mediator.Send(updateGameCommand);
}
public async Task <ActionResult <GameDetailDto> > Update(int id, [FromBody] UpdateGameCommand command)
{
command.Id = id;
var res = await Mediator.Send(command);
return(Ok(await Mediator.Send(new GetGameDetailQuery {
Id = res
})));
}
public async Task <IActionResult> PutGame(
[FromRoute] int id,
[FromBody] UpdateGameCommand command)
{
if (id != command.Game.GameId)
{
return(BadRequest());
}
return(Ok(await Mediator.Send(command)));
}
public async Task <IActionResult> Put(Guid id, [FromBody] UpdateGameCommand command)
{
if (id == default || id != command.Id)
{
return(BadRequest());
}
await _mediator.Send(command);
return(NoContent());
}
public async Task <ActionResult <string> > UpdateGame([FromBody] UpdateGameCommand command)
{
var commandResult = await Mediator.Send(command);
var res = new
{
result = commandResult
};
return(new JsonResult(res));
}
public void ShouldValidateWhenCommandIsValid()
{
var command = new UpdateGameCommand()
{
Id = Guid.NewGuid(),
Name = "FIFA 19",
CompanyId = Guid.NewGuid()
};
Assert.True(command.Valid());
}
public void ShouldUpdateGameWhenCommandIsValid()
{
var command = new UpdateGameCommand()
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
Name = "FIFA 19"
};
var result = _handler.Handle(command);
Assert.NotEqual(null, result);
Assert.True(_handler.Valid);
}
public async Task ShouldUpdateGame()
{
var cmd = new UpdateGameCommand(_entity.Id, "Call of Duty: Black Ops Cold War", 2020, "X-Box", _entity.Ver);
await SendAsync(cmd);
var entity = await FindAsync <IGameRepository, Game>(_entity.Id);
entity.Should().NotBeNull();
entity.Id.Should().Be(_entity.Id);
entity.Name.Should().Be("Call of Duty: Black Ops Cold War");
entity.LaunchYear.Should().Be(2020);
entity.Platform.Should().Be("X-Box");
}
public ICommandResult Handle(UpdateGameCommand command)
{
var gameCompany = _gameCompanyRepository.Get(command.CompanyId);
var game = _repository.Get(command.Id);
game.Alter(command.Name, gameCompany);
AddNotifications(game.Notifications);
if (Invalid)
{
return(ErrorResult());
}
_repository.Update(game);
return(new GameCommandResult(true, "Jogo alterado com sucesso", game.Id));
}
public void ShouldThrowMessageGameNotFound()
{
GenerateMock();
_gameRepositoryMock
.Setup(x => x.FindAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>()));
var handler = GetHandler();
var command = new UpdateGameCommand(Guid.NewGuid(), "", 0, "", null);
FluentActions.Invoking(async() => await handler.Handle(command, default))
.Should()
.Throw <NotFoundException>().WithMessage("Game not found!");
_gameRepositoryMock
.Verify(x => x.FindAsync(It.Is <Guid>(f => f.Equals(command.Id)), It.IsAny <CancellationToken>()));
}
public async Task <ValidationResult> Handle(UpdateGameCommand message, CancellationToken cancellationToken)
{
if (!message.IsValid())
{
return(message.ValidationResult);
}
var game = new GameModel(Guid.NewGuid(), message.Description, message.Active, message.Created, message.Updated);
if (await _gameRepository.GetByDescription(game.Description) != null)
{
AddError("Game já cadastrado.");
return(ValidationResult);
}
game.AddDomainEvent(new GameRegisteredEvent(game.Description, game.Active, game.Created, game.Updated));
_gameRepository.Update(game);
return(await Commit(_gameRepository.UnitOfWork));
}
public async Task Handle(GameUpdatedEvent @event)
{
UpdateGameCommand command = _mapper.Map <UpdateGameCommand>(@event);
await _mediator.Send(command);
}
public async Task <IActionResult> Update([FromBody] UpdateGameCommand command)
{
await Mediator.Send(command);
return(NoContent());
}
public async Task <IActionResult> UpdateFriend([FromForm] UpdateGameCommand command)
{
return(Ok(await Mediator.Send(command)));
}
public async Task <ICommandResult> Put([FromBody] UpdateGameCommand command)
{
var result = _handler.Handle(command);
return(await Response(result));
}
public async Task Put([FromBody] UpdateGameCommand command)
{
await CommandPublisher.ExecuteAsync(command);
}
public async Task <IActionResult> Put([FromRoute] Guid id, [FromBody] UpdateGameCommand command)
{
command.Id = id;
return(Ok(await Mediator.Send(command)));
}
