public async Task Get_carrinho_cliente_carrinho_not_found()
{
//arrange
string clienteId = "123";
CarrinhoCliente carrinhoFake = GetCarrinhoClienteFake(clienteId);
_carrinhoRepositoryMock
.Setup(r => r.GetCarrinhoAsync(clienteId))
.ReturnsAsync((CarrinhoCliente)null)
.Verifiable();
var controller =
new CarrinhoController(_carrinhoRepositoryMock.Object,
_identityServiceMock.Object, _serviceBusMock.Object);
//act
IActionResult actionResult = await controller.Get(clienteId);
//assert
OkObjectResult okObjectResult = Assert.IsType <OkObjectResult>(actionResult);
CarrinhoCliente carrinhoCliente = Assert.IsAssignableFrom <CarrinhoCliente>(okObjectResult.Value);
Assert.Equal(clienteId, carrinhoCliente.ClienteId);
_carrinhoRepositoryMock.Verify();
}
public async Task Get_carrinho_cliente_sucesso()
{
//Arrange
var fakeClienteId = "1";
var carrinhoFake = GetCarrinhoClienteFake(fakeClienteId);
_carrinhoRepositoryMock
.Setup(x => x.GetCarrinhoAsync(It.IsAny <string>()))
.Returns(Task.FromResult(carrinhoFake))
.Verifiable();
_identityServiceMock.Setup(x => x.GetUserIdentity()).Returns(fakeClienteId);
_serviceBusMock.Setup(x => x.Publish(It.IsAny <CheckoutEvent>(), null));
//Act
var carrinhoController = new CarrinhoController(
_carrinhoRepositoryMock.Object,
_identityServiceMock.Object,
_serviceBusMock.Object);
var actionResult = await carrinhoController.Get(fakeClienteId) as OkObjectResult;
//Assert
OkObjectResult okObjectResult = Assert.IsType <OkObjectResult>(actionResult);
CarrinhoCliente carrinhoCliente = Assert.IsAssignableFrom <CarrinhoCliente>(okObjectResult.Value);
Assert.Equal(fakeClienteId, carrinhoCliente.ClienteId);
Assert.Equal(carrinhoFake.Itens[0].ProdutoId, carrinhoCliente.Itens[0].ProdutoId);
Assert.Equal(carrinhoFake.Itens[1].ProdutoId, carrinhoCliente.Itens[1].ProdutoId);
Assert.Equal(carrinhoFake.Itens[2].ProdutoId, carrinhoCliente.Itens[2].ProdutoId);
_carrinhoRepositoryMock.Verify();
_identityServiceMock.Verify();
_serviceBusMock.Verify();
}
public async Task AddItem_success()
{
//arrange
var clienteId = "123";
var carrinho = GetCarrinhoClienteFake(clienteId);
ItemCarrinho input = new ItemCarrinho("004", "004", "produto 004", 45.67m, 4);
var itens = carrinho.Itens;
itens.Add(input);
_carrinhoRepositoryMock
.Setup(c => c.AddCarrinhoAsync(clienteId, It.IsAny <ItemCarrinho>()))
.ReturnsAsync(new CarrinhoCliente
{
ClienteId = clienteId,
Itens = itens
})
.Verifiable();
var controller = new CarrinhoController(
_carrinhoRepositoryMock.Object,
_identityServiceMock.Object,
_serviceBusMock.Object);
//act
ActionResult <CarrinhoCliente> actionResult = await controller.AddItem(clienteId, input);
//assert
OkObjectResult okObjectResult = Assert.IsType <OkObjectResult>(actionResult.Result);
CarrinhoCliente carrinhoCliente = Assert.IsAssignableFrom <CarrinhoCliente>(okObjectResult.Value);
Assert.Equal(4, carrinhoCliente.Itens.Count());
_carrinhoRepositoryMock.Verify();
_identityServiceMock.Verify();
_serviceBusMock.Verify();
}
private async Task <CarrinhoItem> ObterItemCarrinhoValidado(Guid produtoId, CarrinhoCliente carrinho, CarrinhoItem item = null)
{
if (item != null && produtoId != item.ProdutoId)
{
AdicionarErroProcessamento("O item não corresponde ao informado");
return(null);
}
if (carrinho == null)
{
AdicionarErroProcessamento("Carrinho não encontrado");
return(null);
}
var itemCarrinho = await _context.CarrinhoItens
.FirstOrDefaultAsync(i => i.CarrinhoId == carrinho.Id && i.ProdutoId == produtoId);
if (itemCarrinho == null || !carrinho.CarrinhoItemExistente(itemCarrinho))
{
AdicionarErroProcessamento("O item não está no carrinho");
return(null);
}
return(itemCarrinho);
}
public async Task <UpdateQuantidadeOutput> UpdateItemCarrinhoAsync(string customerId, UpdateQuantidadeInput item)
{
if (item == null)
{
throw new ArgumentNullException();
}
if (string.IsNullOrWhiteSpace(item.Id))
{
throw new ArgumentException();
}
if (item.Quantity < 0)
{
throw new ArgumentOutOfRangeException();
}
var basket = await GetCarrinhoAsync(customerId);
ItemCarrinho itemDB = basket.Itens.Where(i => i.ProdutoId == item.Id).SingleOrDefault();
itemDB.Quantidade = item.Quantity;
if (item.Quantity == 0)
{
basket.Itens.Remove(itemDB);
}
CarrinhoCliente customerBasket = await UpdateCarrinhoAsync(basket);
return(new UpdateQuantidadeOutput(itemDB, customerBasket));
}
private void ManipularNovoCarrinho(CarrinhoItem item)
{
var carrinho = new CarrinhoCliente(_user.ObterUserId());
carrinho.AdicionarItem(item);
_context.CarrinhoCliente.Add(carrinho);
}
private async Task ManipularNovoCarinho(CarrinhoItem item)
{
var carrinho = new CarrinhoCliente(_user.ObterUserId());
carrinho.AdicionarItem(item);
ValidarCarrinho(carrinho);
await _carrinhoRepository.Adicionar(carrinho);
}
private static void PrintCarrinho(CarrinhoCliente carrinhoCliente)
{
foreach (var item in carrinhoCliente.Itens)
{
System.Console.WriteLine(
$"Id: {item.Id}, PrecoUnitario: {item.PrecoUnitario}, ProdutoId: {item.ProdutoId}, ProdutoNome: {item.ProdutoNome}, Quantidade: {item.Quantidade}, UrlImagem: {item.UrlImagem}"
);
}
}
private bool ValidarCarrinho(CarrinhoCliente carrinho)
{
if (carrinho.EhValido())
{
return(true);
}
AdicionarErroProcessamento(carrinho.ValidationResult);
return(false);
}
private bool ValidarCarrinho(CarrinhoCliente carrinho)
{
if (carrinho.EhValido())
{
return(true);
}
carrinho.ValidationResult.Errors.ToList().ForEach(e => AdicionarErroProcessamento(e.ErrorMessage));
return(false);
}
public async Task <CarrinhoCliente> UpdateCarrinhoAsync(CarrinhoCliente carrinho)
{
var criado = await _database.StringSetAsync(carrinho.ClienteId, JsonConvert.SerializeObject(carrinho));
if (!criado)
{
_logger.LogError("Erro ao atualizar o carrinho.");
return(null);
}
return(await GetCarrinhoAsync(carrinho.ClienteId));
}
public async Task <IActionResult> AdicionarAoCarrinho([FromBody] string codigo)
{
if (string.IsNullOrWhiteSpace(codigo))
{
return(NotFound(codigo));
}
CarrinhoCliente carrinho = await AdicionarProdutoAsync(codigo);
return(base.Ok(carrinho));
}
private void ManipularCarrinhoExistente(CarrinhoCliente carrinho, CarrinhoItem item)
{
var produtoItemExistente = carrinho.CarrinhoItemExistente(item);
carrinho.AdicionarItem(item);
ValidarCarrinho(carrinho);
if (produtoItemExistente)
{
context.CarrinhoItens.Update(carrinho.ObterPorProdutoId(item.ProdutoId));
}
else
{
context.CarrinhoItens.Add(item);
}
context.CarrinhoCliente.Update(carrinho);
}
private async Task ManipularCarinhoExistente(CarrinhoCliente carrinho, CarrinhoItem item)
{
var carrinhoItemExiste = carrinho.CarrinhoItemExiste(item);
carrinho.AdicionarItem(item);
if (carrinhoItemExiste)
{
_carrinhoRepository.AtualizarItem(carrinho.ObterProdutoPorId(item.ProdutoId));
}
else
{
await _carrinhoRepository.AdicionarItem(item);
}
ValidarCarrinho(carrinho);
_carrinhoRepository.Atualizar(carrinho);
}
public async Task <IActionResult> Post([FromBody] CarrinhoCliente input)
{
if (!ModelState.IsValid)
{
return(BadRequest(input));
}
try
{
var carrinho = await _repository.UpdateCarrinhoAsync(input);
return(Ok(carrinho));
}
catch (KeyNotFoundException)
{
return(NotFound());
}
}
public async Task <IActionResult> Post([FromBody] CarrinhoCliente input)
{
if (!ModelState.IsValid)
{
return(BadRequest(input));
}
try
{
var carrinho = await _repository.UpdateCarrinhoAsync(input);
await this._connection
.InvokeAsync("UpdateUserBasketCount", $"{input.ClienteId}", carrinho.Itens.Count);
return(Ok(carrinho));
}
catch (KeyNotFoundException)
{
return(NotFound());
}
}
protected async override Task ExecutarPlayground()
{
carrinhoClient = new Carrinho.Generated.Client(ApiConfiguration.BaseUrlCarrinho, httpClient);
System.Console.WriteLine("ApiCarrinhoPostAsync...");
CarrinhoCliente carrinho = new CarrinhoCliente
{
ClienteId = usuarioInput.UsuarioId,
Itens = new ObservableCollection <ItemCarrinho>(new List <ItemCarrinho>
{
new ItemCarrinho {
Id = "1", PrecoUnitario = 49.90, ProdutoId = "001", ProdutoNome = "ASP.NET Core MVC", Quantidade = 2, UrlImagem = "http:\\img1.images.com}"
},
new ItemCarrinho {
Id = "2", PrecoUnitario = 49.90, ProdutoId = "002", ProdutoNome = "Construct 2", Quantidade = 3, UrlImagem = "http:\\img2.images.com}"
}
})
};
await carrinhoClient.ApiCarrinhoPostAsync(carrinho);
System.Console.WriteLine("ApiCarrinhoByIdGetAsync...");
var carrinhoCliente = await carrinhoClient.ApiCarrinhoByIdGetAsync(usuarioInput.UsuarioId);
PrintCarrinho(carrinhoCliente);
System.Console.WriteLine("ApiCarrinhoPostAsync...");
carrinho.Itens[0].Quantidade = 4;
carrinho.Itens[1].Quantidade = 5;
await carrinhoClient.ApiCarrinhoPostAsync(carrinho);
carrinhoCliente = await carrinhoClient.ApiCarrinhoByIdGetAsync(usuarioInput.UsuarioId);
PrintCarrinho(carrinhoCliente);
System.Console.WriteLine("ApiCarrinhoCheckoutPostAsync...");
Guid guid = Guid.NewGuid();
await carrinhoClient.ApiCarrinhoCheckoutPostAsync(carrinhoCliente, guid.ToString());
}
private async Task <CarrinhoItem> ObterItemCarrinhoValidado(Guid produtoId, CarrinhoCliente carrinho, CarrinhoItem item = null)
{
if (item != null && produtoId != item.ProdutoId)
{
AdicionarErroProcessamento("O item não corresponde ao id informado!");
return(null);
}
if (carrinho is null)
{
AdicionarErroProcessamento("Carrinho não encontrado!");
return(null);
}
var itemCarrinho = await _carrinhoRepository.ObterCarrinhoItem(carrinho.Id, produtoId);
if (itemCarrinho is null)
{
AdicionarErroProcessamento("O item não está no carrinho!");
}
return(itemCarrinho);
}
private static CarrinhoClienteResponse MapCarrinhoClienteToResponse(CarrinhoCliente carrinho)
{
var carrinhoProto = new CarrinhoClienteResponse
{
Id = carrinho.Id.ToString(),
Clienteid = carrinho.ClienteId.ToString(),
Valortotal = (double)carrinho.ValorTotal,
Desconto = (double)carrinho.Desconto,
Voucherutilizado = carrinho.VoucherUtilizado
};
if (carrinho.Voucher != null)
{
carrinhoProto.Voucher = new VoucherResponse
{
Codigo = carrinho.Voucher.Codigo,
Percentual = (double?)carrinho.Voucher.Percentual ?? 0,
Valordesconto = (double?)carrinho.Voucher.ValorDesconto ?? 0,
Tipodesconto = (int)carrinho.Voucher.TipoDesconto,
};
}
foreach (var item in carrinho.Itens)
{
carrinhoProto.Itens.Add(new CarrinhoItemResponse
{
Id = item.Id.ToString(),
Nome = item.Nome,
Imagem = item.Imagem,
Produtoid = item.ProdutoId.ToString(),
Quantidade = item.Quantidade,
Valor = (double)item.Valor
});
}
return(carrinhoProto);
}
public Task AtualizarCarrinho(CarrinhoCliente carrinhoCliente)
{
throw new System.NotImplementedException();
}
public UpdateQuantidadeOutput(ItemCarrinho basketItem, CarrinhoCliente customerBasket)
{
BasketItem = basketItem;
CustomerBasket = customerBasket;
}
public UpdateQuantidadeOutput(ItemCarrinho itemPedido, CarrinhoCliente carrinhoCliente)
{
ItemPedido = itemPedido;
CarrinhoCliente = carrinhoCliente;
}
public async Task Adicionar(CarrinhoCliente carrinhoCliente)
{
await _context.CarrinhoCliente.AddAsync(carrinhoCliente);
}
public void Atualizar(CarrinhoCliente carrinhoCliente)
{
_context.CarrinhoCliente.Update(carrinhoCliente);
}
private async Task PublicarEventoFechamentoDoCarrinho(string clienteId, CadastroViewModel input, CarrinhoCliente carrinho)
{
var itens = carrinho.Itens.Select(i =>
new CheckoutEventItem(i.Id, i.ProdutoId, i.ProdutoNome, i.PrecoUnitario, i.Quantidade)).ToList();
var checkoutEvent
= new CheckoutEvent
(clienteId, input.Nome, input.Email, input.Telefone
, input.Endereco, input.Complemento, input.Bairro
, input.Municipio, input.UF, input.CEP
, Guid.NewGuid()
, itens);
// Assim que fazemos a finalização, envia um evento de integração para
// API OrdemDeCompra converter o carrinho em pedido e continuar com
// processo de criação de pedido
await _bus.Publish(checkoutEvent);
_logger.LogInformation(eventId: EventId_Checkout, message: "Evento de check out foi enviado: {CheckoutEvent}", args: checkoutEvent);
}
public UpdateQuantidadeOutput(ItemCarrinho itemCarrinho, CarrinhoCliente carrinho)
{
ItemCarrinho = itemCarrinho;
Carrinho = carrinho;
}
