public async Task <Result <CommandResult> > Handle(UpdateCardCommand request, CancellationToken cancellationToken)
{
if (!request.IsValid())
{
await PublishValidationErrorsAsync(request);
return(Result.Failure <CommandResult>(ApplicationMessages.Update_Failed));
}
var project = await _projectRepository.GetByIdAsync(request.Id);
var exist = await _projectRepository.ExistByNameAsync(project.Id, request.Name);
if (exist)
{
await _mediator.Publish(new DomainNotification("", ApplicationMessages.Name_Already_Exist));
return(Result.Failure <CommandResult>(ApplicationMessages.Update_Failed));
}
project.SetName(request.Name);
project.SetDescription(request.Description);
project.SetType(request.Type);
await _projectRepository.UpdateAsync(project);
return(Result.Success(new CommandResult(project.Id, ApplicationMessages.Update_Success)));
}
public async Task <IActionResult> UpdateCardAsync([FromBody] UpdateCardCommand command)
{
if (command == null)
{
return(BadRequest());
}
var cardToUpdate = new Card
{
Id = command.Id,
Name = command.Name,
Description = command.Description
};
var updatedCard = await _cardsService.UpdateCardAsync(cardToUpdate);
if (updatedCard == null)
{
return(NotFound());
}
var response = new CardResponse
{
Id = updatedCard.Id,
Name = updatedCard.Name,
Description = updatedCard.Description
};
return(Ok(response));
}
public async Task Given_A_Valid_Card_ISuccessful_Should_Be_True()
{
// Arrange
var command = new UpdateCardCommand
{
Card = new CardInputModel
{
CardType = YgoCardType.Spell,
Name = "Monster Reborn",
Description = "Special Summon a monster from any graveyard",
ImageUrl = new Uri("http://cardimageurl.com/card/image.jpg")
}
};
_cardService.Update(Arg.Any <CardModel>()).Returns(new Card {
Id = 23424
});
_settings.Value.Returns(new AppSettings
{
CardImageFolderPath = "C:/cards/images"
});
// Act
var result = await _sut.Handle(command, CancellationToken.None);
// Assert
result.IsSuccessful.Should().BeTrue();
}
public Task <bool> Handle(UpdateCardCommand message, CancellationToken cancellationToken)
{
if (!message.IsValid())
{
NotifyValidationErrors(message);
return(Task.FromResult(false));
}
var card = new Card(message.Id, message.IdCustomer, message.IdBrand, message.IdCardType, message.CardNumber, message.ExpirationDate, message.HasPassword, message.Password, message.Limit, message.LimitAvailable, message.Attempts, message.Blocked);
var existingCard = _cardRepository.GetByCardNumber(card.CardNumber);
if (existingCard != null && existingCard.Id != card.Id)
{
if (!existingCard.Equals(card))
{
Bus.RaiseEvent(new DomainNotification(message.MessageType, "The card number has already been taken."));
return(Task.FromResult(false));
}
}
_cardRepository.Update(card);
if (Commit())
{
Bus.RaiseEvent(new CardUpdatedEvent(message.Id, message.IdCustomer, message.IdBrand, message.IdCardType, message.CardNumber, message.ExpirationDate, message.HasPassword, StringCipher.Encrypt(message.Password, "StefanSilva@#@Stone##2019"), message.Limit, message.LimitAvailable, message.Attempts, message.Blocked));
}
return(Task.FromResult(true));
}
public async Task Given_A_Valid_Card_With_An_ImageUrl_Should_Invoke_DownloadImageCommand()
{
// Arrange
var command = new UpdateCardCommand
{
Card = new CardInputModel
{
CardType = YgoCardType.Spell,
Name = "Monster Reborn",
Description = "Special Summon a monster from any graveyard",
ImageUrl = new Uri("http://cardimageurl.com/card/image.jpg")
}
};
_cardService.Update(Arg.Any <CardModel>()).Returns(new Card {
Id = 23424
});
_settings.Value.Returns(new AppSettings
{
CardImageFolderPath = "C:/cards/images"
});
// Act
await _sut.Handle(command, CancellationToken.None);
// Assert
await _mediator.Received(1).Send(Arg.Any <DownloadImageCommand>(), Arg.Any <CancellationToken>());
}
public async Task Given_A_Valid_Card_Should_Invoke_CardService_Update_Method_Once()
{
// Arrange
var command = new UpdateCardCommand
{
Card = new CardInputModel
{
CardType = YgoCardType.Trap,
Name = "Call of the Haunted",
Description = "Activate this card by targeting 1 monster in your GY; Special Summon that target in Attack Position. When this card leaves the field, destroy that target. When that target is destroyed, destroy this card",
ImageUrl = new Uri("http://cardimageurl.com/card/image.jpg")
}
};
_cardService.Update(Arg.Any <CardModel>()).Returns(new Card {
Id = 23424
});
_settings.Value.Returns(new AppSettings
{
CardImageFolderPath = "C:/cards/images"
});
// Act
await _sut.Handle(command, CancellationToken.None);
// Assert
await _cardService.Received(1).Update(Arg.Any <CardModel>());
}
public Task <UpdateCardCommandResult> Update(UpdateCardCommand command)
{
Task <UpdateCardCommandResult> result;
result = _mediator.Send(command);
return(result);
}
public async Task <IActionResult> Update(
[FromServices] IMediator mediator,
[FromBody] BusinessCardDto cardDto)
{
var command = new UpdateCardCommand(cardDto);
var data = await mediator.Send(command);
return(new JsonResult(data.Card));
}
public async Task <ActionResult> Update(UpdateCardCommand command)
{
await Mediator.Send(new UpdateCardCommand
{
Id = command.Id,
Back = command.Back,
Front = command.Front
});
return(NoContent());
}
public async Task <ActionResult> Update(int id, UpdateCardCommand command)
{
if (id != command.Id)
{
return(BadRequest());
}
await Mediator.Send(command);
return(NoContent());
}
public async Task Given_An_Invalid_UpdateCardCommand_Should_Return_A_List_Of_Errors()
{
// Arrange
var command = new UpdateCardCommand {
Card = new CardInputModel()
};
// Act
var result = await _sut.Handle(command, CancellationToken.None);
// Assert
result.Errors.Should().NotBeEmpty();
}
public async Task Given_An_Invalid_UpdateCardCommand_Validation_Should_Fail()
{
// Arrange
var command = new UpdateCardCommand {
Card = new CardInputModel()
};
// Act
var result = await _sut.Handle(command, CancellationToken.None);
// Assert
result.IsSuccessful.Should().BeFalse();
}
public async Task <UpdateCardCommand> MapToUpdateCommand(YugiohCard yugiohCard, Card cardToUpdate)
{
ICollection <Category> categories = await _categoryService.AllCategories();
ICollection <SubCategory> subCategories = await _subCategoryService.AllSubCategories();
var command = new UpdateCardCommand
{
Card = await MapToCardInputModel(yugiohCard, new CardInputModel(), categories, subCategories, cardToUpdate)
};
return(command);
}
void AndGivenRequest()
{
var content = new UpdateCardCommand
{
Id = 1,
Front = new Side {
Value = "heads123", Example = "example123"
},
Back = new Side {
Value = "tails123", Example = "example456"
},
IsVisible = false
};
Request.Content = new StringContent(JsonSerializer.Serialize(content), Encoding.UTF8, "application/json");
}
public async Task Given_A_Valid_Card_And_UpdateCardCommand_Fails_Should_Return_Error_List()
{
// Arrange
var command = new UpdateCardCommand
{
Card = new CardInputModel
{
CardType = YgoCardType.Spell,
Name = "Monster Reborn",
Description = "Special Summon a monster from any graveyard"
}
};
_cardService.Update(Arg.Any <CardModel>()).Returns((Card)null);
// Act
var result = await _sut.Handle(command, CancellationToken.None);
// Assert
result.Errors.Should().NotBeEmpty();
}
public Task <Card> Update(UpdateCardCommand command)
{
return(_restClient.Put <UpdateCardCommand, Card>($"{_config.ApiUrl}/api/Cards", command));
}
public async Task <IActionResult> UpdateCard([FromBody] UpdateCardCommand command)
{
return(Ok(await Mediator.Send(command)));
}
public WebApiResult <CardItem> Put(int id, [FromBody] UpdateCardCommand command)
{
var result = _repository.ExecuteCommand(command);
return(AutoMapper.Mapper.Map <CommandResult <Card>, WebApiResult <CardItem> >(result));
}
public async Task <IActionResult> Update(UpdateCardCommand command)
{
var card = await Mediator.Send(command);
return(Ok(card));
}
public async Task <IActionResult> Update([FromBody] UpdateCardCommand command)
{
var vm = await Mediator.Send(command);
return(Ok(vm));
}
public async Task <IActionResult> Update([FromBody] UpdateCardCommand command) => await HandleCommand(command);
