public ActionResult AtualizarItem(int idProduto)
{
int quantidade = Convert.ToInt32(Request["quantity"]);
if (quantidade == 0 || quantidade < 0)
{
quantidade = 1;
}
List <String> itensIds = new List <string>();
List <ItemCarrinho> carrinho = ObterCarrinhoEmCookies();
ItemCarrinho item = carrinho.FirstOrDefault <ItemCarrinho>(p => p.Produto.Id == idProduto);
if (item != null)
{
item.Quantidade = quantidade;
item.Total = item.Produto.Valor * item.Quantidade;
foreach (var itemCar in carrinho)
{
itensIds.Add(Convert.ToString(itemCar.Produto.Id) + ">" + itemCar.Quantidade);
}
GravarCookiesCarrinho(itensIds);
}
return(RedirectToAction("Carrinho"));
}
public async Task <CarrinhoCliente> AddItemCarrinhoAsync(string clienteId, ItemCarrinho item)
{
if (item == null)
{
throw new ArgumentNullException();
}
if (string.IsNullOrWhiteSpace(item.ProdutoId))
{
throw new ArgumentException();
}
if (item.Quantidade <= 0)
{
throw new ArgumentOutOfRangeException();
}
var carrinho = await GetCarrinhoAsync(clienteId);
ItemCarrinho itemDB = carrinho.Itens.Where(i => i.ProdutoId == item.ProdutoId).SingleOrDefault();
if (itemDB == null)
{
itemDB = new ItemCarrinho(item.Id, item.ProdutoId, item.ProdutoNome, item.PrecoUnitario, item.Quantidade);
carrinho.Itens.Add(item);
}
return(await UpdateCarrinhoAsync(carrinho));
}
decimal Calcular(ItemCarrinho item)
{
var total = item.Quantidade * 0.4;
var pacoteDeTres = item.Quantidade / 3;
return(total - pacoteDeTres * 0.2);
}
public List <ItemCarrinho> AdicionarAoCarrinho(Guid itemId, int Quantidade, Cliente cliente)
{
var carrinho = cr.VerificarCarrinhoExistente(cliente.ClienteId);
if (carrinho != null)
{
ItemCarrinho item = new ItemCarrinho();
item.ProdutoId = itemId;
item.CarrinhoDeComprasId = carrinho.CarrinhoDeComprasId;
item.Quantidade = Quantidade;
return(cr.AdicionarAoCarrinho(item));
}
else
{
CarrinhoDeCompras NovoCarrinho = new CarrinhoDeCompras();
NovoCarrinho.ClienteId = cliente.ClienteId;
NovoCarrinho.DataCompra = DateTime.Now;
NovoCarrinho.StatusId = 0;
NovoCarrinho = cr.CriarCarrinho(NovoCarrinho);
ItemCarrinho item = new ItemCarrinho();
item.ProdutoId = itemId;
item.CarrinhoDeComprasId = NovoCarrinho.CarrinhoDeComprasId;
item.Quantidade = Quantidade;
return(cr.AdicionarAoCarrinho(item));
}
}
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();
}
public async Task Index_Without_Product_Success()
{
//arrange
var clienteId = "cliente_id";
var produtos = GetFakeProdutos();
var testProduct = produtos[0];
var itemCarrinho = new ItemCarrinho(testProduct.Codigo, testProduct.Codigo, testProduct.Nome, testProduct.Preco, 1, testProduct.UrlImagem);
carrinhoServiceMock
.Setup(c => c.GetCarrinho(clienteId))
.ReturnsAsync(
new CarrinhoCliente(clienteId,
new List <ItemCarrinho>
{
itemCarrinho
}))
.Verifiable();
var controller = GetCarrinhoController();
SetControllerUser(clienteId, controller);
//act
var result = await controller.Index();
//assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <CarrinhoCliente>(viewResult.Model);
Assert.Equal(model.Itens[0].ProdutoNome, produtos[0].Nome);
carrinhoServiceMock.Verify();
}
public PartialViewResult AddProduto(FormCollection collection)
{
List <ItemCarrinho> carrinho = HttpContext.Session["carrinho"] as List <ItemCarrinho>;
var produto = produtoServico.ObterProdutoPorId(Convert.ToInt32(collection.Get("idproduto")));
var indexOf = carrinho.IndexOf(carrinho.Find(i => i.Produto.ProdutoId == produto.ProdutoId));
if (indexOf == -1)
{
var itemCarrinho = new ItemCarrinho()
{
Produto = produto,
Quantidade = 1,
ValorUnitario = produto.ValorUnitario
};
carrinho.Add(itemCarrinho);
}
else
{
carrinho[indexOf].Quantidade += 1;
}
HttpContext.Session["carrinho"] = carrinho;
return(PartialView("_ItensCarrinho", carrinho));
}
public void Carrinho_ValorComDescontoPromocionalCorreto_SemDesconto_Sucesso_False()
{
var carrinho = new Carrinho();
var itemCarrinho = new ItemCarrinho()
{
Produto = new Produto()
{
Nome = "Sabonete",
Preco = 5
},
Quantidade = 3
};
var itemCarrinho2 = new ItemCarrinho()
{
Produto = new Produto()
{
Nome = "Sabonete",
Preco = 5
},
Quantidade = 3
};
carrinho.AdicionarItem(itemCarrinho);
carrinho.AdicionarItem(itemCarrinho2);
Assert.IsTrue(carrinho.ValorTotalCarrinhoComDescontoPromocional == 30);
}
public void AtualizarItensCarrinhoDeveRemoverItensDoCarrinhoQuandoProdutoForNull()
{
//Arrange
var produto1 = new Produto()
{
Codigo = 1
};
var produto2 = new Produto()
{
Codigo = 2
};
var itemCarrinho2 = new ItemCarrinho(produto2);
var carrinho = new Carrinho()
{
ItensCarrinho = new List <ItemCarrinho>()
{
new ItemCarrinho(produto1),
itemCarrinho2
}
};
itemCarrinho2.Produto = null;
//Act
carrinho.AtualizarItensCarrinho();
//Assert
carrinho.ItensCarrinho.Count.Should().Be(1);
carrinho.ItensCarrinho.All(p => p.Produto != null).Should().BeTrue();
}
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));
}
async Task <CarrinhoCliente> AdicionarProdutoAsync(string codigo = null)
{
string idUsuario = GetUserId();
CarrinhoCliente carrinho;
if (!string.IsNullOrWhiteSpace(codigo))
{
var product = await catalogoService.GetProduto(codigo);
if (product == null)
{
return(null);
}
ItemCarrinho itemCarrinho =
new ItemCarrinho(product.Codigo
, product.Codigo
, product.Nome
, product.Preco
, 1
, product.UrlImagem);
carrinho = await carrinhoService.AddItem(idUsuario, itemCarrinho);
await CheckUserCounterData();
}
else
{
carrinho = await carrinhoService.GetCarrinho(idUsuario);
}
return(carrinho);
}
public void Carrinho_ValorComDescontoPromocionalCorreto_PagueUmLeveDois_Sucesso_False()
{
var carrinho = new Carrinho();
var itemCarrinho = new ItemCarrinho()
{
Produto = new Produto()
{
Nome = "Sabonete",
Preco = 5,
TipoPromocao = TipoPromocao.PagueUmLeveDois
},
Quantidade = 2
};
var itemCarrinho2 = new ItemCarrinho()
{
Produto = new Produto()
{
Nome = "Sabonete",
Preco = 5,
TipoPromocao = TipoPromocao.PagueUmLeveDois
},
Quantidade = 2
};
carrinho.AdicionarItem(itemCarrinho);
carrinho.AdicionarItem(itemCarrinho2);
Assert.IsTrue(carrinho.ValorTotalCarrinhoComDescontoPromocional == 10);
}
public List <ItemCarrinho> AdicionarAoCarrinho(ItemCarrinho item)
{
db.ItensCarrinho.Add(item);
db.SaveChanges();
AtualizarValorTotalCarrinho(item.CarrinhoDeComprasId);
return(db.ItensCarrinho.Include("Produto").Where(i => i.CarrinhoDeComprasId == item.CarrinhoDeComprasId).ToList());
}
public ActionResult RemoverItem(int idProd, int idCar)
{
ItemCarrinhoDAO dao = new ItemCarrinhoDAO();
ItemCarrinho ic = dao.BuscarPorIdCarProd(idProd, idCar);
dao.Remover(ic);
return(RedirectToAction("ConfirmCarrinho"));
}
protected ItemCarrinho GetFakeItemCarrinho()
{
var produtos = GetFakeProdutos();
var testProduct = produtos[0];
var itemCarrinho = new ItemCarrinho(testProduct.Codigo, testProduct.Codigo, testProduct.Nome, testProduct.Preco, 7, testProduct.UrlImagem);
return(itemCarrinho);
}
public void ItemCarrinho_IsValid_Sucesso_False()
{
var itemCarrinho = new ItemCarrinho();
Assert.IsFalse(itemCarrinho.IsValid());
Assert.AreEqual(itemCarrinho.ResultadoValidacao.Erros.Count(), 2);
Assert.IsTrue(itemCarrinho.ResultadoValidacao.Erros.Contains(ItemCarrinhoErrors.messageItemCarrinhoNaoPossuiProduto));
Assert.IsTrue(itemCarrinho.ResultadoValidacao.Erros.Contains(ItemCarrinhoErrors.messageItemCarrinhoNaoPossuiQuantidade));
}
public void ItemCarrinhoDevePossuirQuantidade_Sucesso_True()
{
var itemCarrinho = new ItemCarrinho()
{
Quantidade = 5
};
Assert.IsTrue(new ItemCarrinhoDevePossuirQuantidadeSpecification().IsSatisfiedBy(itemCarrinho));
}
public ActionResult MudarQtd(int Qtd, int IdProd, int IdCar)
{
ItemCarrinhoDAO dao = new ItemCarrinhoDAO();
ItemCarrinho ic = dao.BuscarPorIdCarProd(IdProd, IdCar);
ic.Quantidade = Qtd;
dao.Salvar();
return(RedirectToAction("ConfirmCarrinho"));
}
public ItemCarrinhoDTO(ItemCarrinho itemCarrinho)
{
Quantidade = itemCarrinho.Quantidade;
Produto = new ProdutoDTO(itemCarrinho.Produto);
PorcentagemDesconto = itemCarrinho.PorcentagemDesconto;
ValorUnitario = itemCarrinho.ValorUnitario;
ValorBruto = itemCarrinho.ValorBruto;
ValorDesconto = itemCarrinho.ValorDesconto;
ValorLiquido = itemCarrinho.ValorLiquido;
}
public void AplicarPromocao(ItemCarrinho itemCarrinho)
{
int quantidadeSemPromocao = itemCarrinho.Quantidade % 2;
int quantidadeComPromocao = itemCarrinho.Quantidade / 2;
int quantidadeTotal = quantidadeComPromocao + quantidadeSemPromocao;
decimal valorItemComDescontoPromocional = itemCarrinho.Produto.Preco * quantidadeTotal;
itemCarrinho.ValorDescontoPromocional = itemCarrinho.ValorItemSemDescontoPromocional - valorItemComDescontoPromocional;
}
public void ItemCarrinhoDevePossuirProduto_Sucesso_True()
{
var produto = new Produto();
var itemCarrinho = new ItemCarrinho()
{
Produto = produto
};
Assert.IsTrue(new ItemCarrinhoDevePossuirProdutoSpecification().IsSatisfiedBy(itemCarrinho));
}
public void AplicarPromocao(ItemCarrinho itemCarrinho)
{
int quantidadeSemPromocao = itemCarrinho.Quantidade % 3;
int quantidadeComPromocao = itemCarrinho.Quantidade / 3;
decimal valorComPromocao = quantidadeComPromocao * 10;
decimal valorSemPromocao = quantidadeSemPromocao * itemCarrinho.Produto.Preco;
decimal valorItemComDescontoPromocional = valorComPromocao + valorSemPromocao;
itemCarrinho.ValorDescontoPromocional = itemCarrinho.ValorItemSemDescontoPromocional - valorItemComDescontoPromocional;
}
public Carrinho EditarItemCarrinho(Carrinho carrinho, ItemCarrinho itemCarrinho)
{
var itemEditar = carrinho.SelecionarItemPorId(itemCarrinho.ItemCarrinhoId);
var carrinhoResult = this.AdicionarItemNoCarrinho(carrinho, itemCarrinho);
if (carrinhoResult.ResultadoValidacao.IsValid)
carrinho.RemoverItem(itemEditar);
return carrinhoResult;
}
//=======================================================================
//SELECIONA UM ITEM NO LIST VIEW DO CARRINHO E JOGA PARA UMA NOVA LIST
//PARA USAR OS DADOS EM OUTROS METODOS.
//ABRE MENU
public void ItemSelecionado(object sender, SelectedItemChangedEventArgs e)
{
if (e.SelectedItem != null)
{
var itemSelecionado = e.SelectedItem as ItemCarrinho;
ItemCarrinho = itemSelecionado;
lblDescricaoProduto.Text = itemSelecionado.Descricao;
entQuantidade.Text = Convert.ToString(itemSelecionado.Quatidade);
StatusMenu(true);
}
}
public void ItemCarrinhoConsistente_Sucesso_False()
{
var itemCarrinho = new ItemCarrinho();
var result = new ItemCarrinhoConsistenteValidation().Validar(itemCarrinho);
Assert.IsFalse(result.IsValid);
Assert.AreEqual(result.Erros.Count(), 2);
Assert.IsTrue(result.Erros.Contains(ItemCarrinhoErrors.messageItemCarrinhoNaoPossuiProduto));
Assert.IsTrue(result.Erros.Contains(ItemCarrinhoErrors.messageItemCarrinhoNaoPossuiQuantidade));
}
public void ItemCarrinhoConsistente_Sucesso_True()
{
var itemCarrinho = new ItemCarrinho()
{
Produto = new Produto(),
Quantidade = 5
};
var result = new ItemCarrinhoConsistenteValidation().Validar(itemCarrinho);
Assert.IsTrue(result.IsValid);
}
public ItemCarrinho CadastrarItem(Produto prod, int cId)
{
ItemCarrinho ic = new ItemCarrinho();
ic.IdCarrinho = cId;
ic.IdProduto = prod.Id;
ic.Preco = prod.Preco;
ic.Quantidade = 1;
context.ItemCarrinhos.Add(ic);
context.SaveChanges();
return(ic);
}
public void AplicarPromocao(ItemCarrinho itemCarrinho)
{
if (itemCarrinho.Quantidade >= 3) //Tenho que alterar
{
var itemPromocional = new ItemCarrinho();
itemPromocional.Produto = itemCarrinho.Produto.RetornarProdutoPromocionalAtivo();
itemPromocional.Quantidade = 1;
itemPromocional.ValorDescontoPromocional = itemPromocional.Produto.Preco;
itemCarrinho.Carrinho.AdicionarItemPromocional(itemPromocional);
}
}
public string Add(ItemCarrinho itemCarrinho)
{
try
{
sqlConnection.Insert(itemCarrinho);
return(mensagem = "Adicionado ao carrinho com sucesso");
}
catch (System.Exception)
{
return(mensagem);
}
}
public Carrinho AdicionarItemNoCarrinho(Carrinho carrinho, ItemCarrinho itemCarrinho)
{
bool isValid = itemCarrinho.IsValid();
carrinho.ResultadoValidacao = itemCarrinho.ResultadoValidacao;
if (!isValid)
return carrinho;
carrinho.AdicionarItem(itemCarrinho);
return carrinho;
}
public void AdicionarItem_Sucesso_True()
{
var carrinho = new Carrinho();
var itemCarrinho = new ItemCarrinho()
{
Produto = new Produto(),
Quantidade = 5
};
carrinho.AdicionarItem(itemCarrinho);
Assert.IsTrue(carrinho.Count() == 1);
Assert.IsTrue(carrinho.Contains(itemCarrinho));
}
/// <summary>
/// Calcular o peso total dos itens adicionados no carrinho para calcular frete
/// </summary>
public static decimal valorTotalProdutos(this List <CarrinhoItemProdutoVW> listaItensCarrinho, bool flagAssociadoAdimplente)
{
var valorTotal = new decimal(0);
foreach (var ItemCarrinho in listaItensCarrinho)
{
decimal valorItem = decimal.Multiply(ItemCarrinho.valorComDescontoUnitario(flagAssociadoAdimplente), new decimal(1));
valorTotal = decimal.Add(valorTotal, valorItem);
}
return(valorTotal);
}
public void ItemCarrinho_ValorComDescontoPromocionalCorreto_SemDesconto_Sucesso_False()
{
var itemCarrinho = new ItemCarrinho()
{
Produto = new Produto()
{
Nome = "Sabonete",
Preco = 5
},
Quantidade = 3
};
Assert.IsTrue(itemCarrinho.ValorItemComDescontoPromocional == 15);
}
public void ItemCarrinho_IsValid_Sucesso_True()
{
var itemCarrinho = new ItemCarrinho()
{
Produto = new Produto()
{
Nome = "Sabonete",
Preco = 5
},
Quantidade = 5
};
Assert.IsTrue(itemCarrinho.IsValid());
}
public PartialViewResult AddProduto(FormCollection collection)
{
List <ItemCarrinho> carrinho = HttpContext.Session["carrinho"] as List <ItemCarrinho>;
var produto = produtoServico.ObterProdutoPorId(Convert.ToInt32(collection.Get("idproduto")));
var itemCarrinho = new ItemCarrinho()
{
Produto = produto,
Quantidade = 1,
ValorUnitario = produto.ValorUnitario
};
carrinho.Add(itemCarrinho);
HttpContext.Session["carrinho"] = carrinho;
return(PartialView("_ItensCarrinho", carrinho));
}
public UpdateItemCarrinhoResponse UpdateItemCarrinho(ItemCarrinho itemCarrinho)
{
var itemCarrinhoDb = this.contexto.ItensCarrinho.Where((item) => item.Id == itemCarrinho.Id).SingleOrDefault();
if (itemCarrinhoDb != null)
{
itemCarrinhoDb.AtualizarQuantidade(itemCarrinho.Quantidade);
if (itemCarrinhoDb.Quantidade <= 0)
{
this.contexto.ItensCarrinho.Remove(itemCarrinhoDb);
}
this.contexto.SaveChanges();
}
return(new UpdateItemCarrinhoResponse(itemCarrinhoDb, new CarrinhoViewModel(GetItensCarrinho())));
}
public void ItemCarrinho_ValorComDescontoPromocionalCorreto_PagueUmLeveDois_Sucesso_False()
{
var itemCarrinho = new ItemCarrinho()
{
Produto = new Produto()
{
Nome = "Sabonete",
Preco = 5,
TipoPromocao = TipoPromocao.PagueUmLeveDois
},
Quantidade = 2
};
Assert.IsTrue(itemCarrinho.ValorItemComDescontoPromocional == 5);
}
public void AdicionarItemNoCarrinho_Sucesso_False()
{
var carrinho = new Carrinho();
var itemCarrinho = new ItemCarrinho();
this.carrinhoService = new CarrinhoService();
var carrinhoResult = carrinhoService.AdicionarItemNoCarrinho(carrinho, itemCarrinho);
Assert.IsTrue(carrinhoResult.Count() == 0);
Assert.IsFalse(carrinhoResult.Contains(itemCarrinho));
Assert.IsFalse(carrinhoResult.ResultadoValidacao.IsValid);
Assert.AreEqual(carrinhoResult.ResultadoValidacao.Erros.Count(), 2);
Assert.IsTrue(carrinhoResult.ResultadoValidacao.Erros.Contains(ItemCarrinhoErrors.messageItemCarrinhoNaoPossuiProduto));
Assert.IsTrue(carrinhoResult.ResultadoValidacao.Erros.Contains(ItemCarrinhoErrors.messageItemCarrinhoNaoPossuiQuantidade));
}
public void AdicionarItemNoCarrinho_Sucesso_True()
{
var carrinho = new Carrinho();
var itemCarrinho = new ItemCarrinho()
{
Produto = new Produto(),
Quantidade = 5
};
this.carrinhoService = new CarrinhoService();
var carrinhoResult = carrinhoService.AdicionarItemNoCarrinho(carrinho, itemCarrinho);
Assert.IsTrue(carrinhoResult.ResultadoValidacao.IsValid);
Assert.IsTrue(carrinhoResult.Count() == 1);
Assert.IsTrue(carrinhoResult.Contains(itemCarrinho));
}
//Adicionar item
public void AdicionarItem(Produto produto, int quantidade)
{
ItemCarrinho item = _itemCarrinho.FirstOrDefault(p => p.Produto.ProdutoId == produto.ProdutoId);
if (item == null)
{
_itemCarrinho.Add(new ItemCarrinho
{
Produto = produto,
Quantidade = quantidade
});
}
else
{
item.Quantidade += quantidade;
}
}
public void RetornarDescontoPromocional_TresPorDez_Sucesso_True()
{
var itemCarrinho = new ItemCarrinho()
{
Produto = new Produto()
{
Nome = "Sabonete",
Preco = 5,
TipoPromocao = TipoPromocao.TresPorDezReais
},
Quantidade = 3
};
var itemCarrinho2 = new ItemCarrinho()
{
Produto = new Produto()
{
Nome = "Sabonete",
Preco = 5,
TipoPromocao = TipoPromocao.TresPorDezReais
},
Quantidade = 6
};
var itemCarrinho3 = new ItemCarrinho()
{
Produto = new Produto()
{
Nome = "Sabonete",
Preco = 5,
TipoPromocao = TipoPromocao.TresPorDezReais
},
Quantidade = 7
};
PromocaoTresPorDezReais promocaoTresPorDezReais = new PromocaoTresPorDezReais();
promocaoTresPorDezReais.AplicarPromocao(itemCarrinho);
promocaoTresPorDezReais.AplicarPromocao(itemCarrinho2);
promocaoTresPorDezReais.AplicarPromocao(itemCarrinho3);
Assert.IsTrue(itemCarrinho.ValorDescontoPromocional == 5);
Assert.IsTrue(itemCarrinho2.ValorDescontoPromocional == 10);
Assert.IsTrue(itemCarrinho3.ValorDescontoPromocional == 10);
}
public async Task UpdateItem_carrinho_invalid_model()
{
//arrange
var clienteId = "123";
ItemCarrinho input = new ItemCarrinho("004", "004", "produto 004", 45.67m, 4);
var controller = new CarrinhoController(
_carrinhoRepositoryMock.Object,
_identityServiceMock.Object,
_serviceBusMock.Object);
controller.ModelState.AddModelError("ProdutoId", "Required");
//act
ActionResult <UpdateQuantidadeOutput> actionResult = await controller.UpdateItem(clienteId, new UpdateQuantidadeInput(input.ProdutoId, input.Quantidade));
//assert
Assert.IsType <BadRequestObjectResult>(actionResult.Result);
}
public ActionResult AdicionarAoCarrinho(int id)
{
var produto = DBConfig.Instance.ProdutoRepository.PrimeiroProduto(id);
var carrinho = new List <ItemCarrinho>();
if (produto != null)
{
carrinho = ObterCarrinhoEmCookies();
List <String> itensIds = new List <string>();
if (carrinho == null)
{
var item = new ItemCarrinho()
{
Produto = produto,
Quantidade = 1,
Total = produto.Valor
};
itensIds.Add(Convert.ToString(item.Produto.Id));
GravarCookiesCarrinho(itensIds);
}
else
{
var aux = carrinho.FirstOrDefault <ItemCarrinho>(p => p.Produto.Id == id);
if (aux == null)
{
var item = new ItemCarrinho()
{
Produto = produto,
Quantidade = 1,
Total = produto.Valor
};
carrinho.Add(item);
foreach (var itemCar in carrinho)
{
itensIds.Add(Convert.ToString(itemCar.Produto.Id) + ">" + itemCar.Quantidade);
}
GravarCookiesCarrinho(itensIds);
}
}
}
return(RedirectToAction("Carrinho"));
}
public JsonResult Carrinho(string cart)
{
List <ItemCarrinho> cartList = new List <ItemCarrinho>();
if (cart != null)
{
var produtos = JsonConvert.DeserializeObject <List <ItemCarrinho> >(cart);
foreach (var produto in produtos)
{
var qtd = int.Parse(produto.productQtd.ToString());
if (qtd > 0)
{
var idProduto = int.Parse(produto.productId.ToString());
var resultado = db.Produtos.Where(m => m.idProduto == idProduto).FirstOrDefault();
ItemCarrinho prod = new ItemCarrinho();
prod.productId = idProduto;
prod.productQtd = qtd;
prod.productName = resultado.nomeProduto;
resultado.descontoPromocao = resultado.descontoPromocao == null ? 0 : resultado.descontoPromocao;
prod.productPrice = resultado.precProduto - (decimal)resultado.descontoPromocao;
prod.productTotal = qtd * prod.productPrice;
string imgProduct = string.Empty;
if (resultado.imagem != null)
{
string base64String = Convert.ToBase64String(resultado.imagem);
imgProduct = "data:image/png;base64," + base64String;
}
else
{
imgProduct = "/img/default_product.png";
}
prod.productImage = imgProduct;
cartList.Add(prod);
}
}
Session["Carrinho"] = cartList;
}
return(Json(JsonConvert.SerializeObject(cartList)));
}
public async Task UpdateItem_carrinho_notfound()
{
//arrange
var clienteId = "123";
ItemCarrinho input = new ItemCarrinho("004", "004", "produto 004", 45.67m, 4);
_carrinhoRepositoryMock
.Setup(c => c.UpdateCarrinhoAsync(clienteId, It.IsAny <UpdateQuantidadeInput>()))
.ThrowsAsync(new KeyNotFoundException());
var controller = new CarrinhoController(
_carrinhoRepositoryMock.Object,
_identityServiceMock.Object,
_serviceBusMock.Object);
//act
ActionResult <UpdateQuantidadeOutput> actionResult = await controller.UpdateItem(clienteId, new UpdateQuantidadeInput(input.ProdutoId, input.Quantidade));
//assert
NotFoundObjectResult notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(actionResult.Result);
Assert.Equal(clienteId, notFoundObjectResult.Value);
}
public async Task <IActionResult> Index(string codigo = null)
{
try
{
string idUsuario = GetUserId();
CarrinhoCliente carrinho;
if (!string.IsNullOrWhiteSpace(codigo))
{
var produto = await catalogoService.GetProduto(codigo);
if (produto == null)
{
return(RedirectToAction("ProdutoNaoEncontrado", "Carrinho", codigo));
}
ItemCarrinho itemCarrinho = new ItemCarrinho(produto.Codigo, produto.Codigo, produto.Nome, produto.Preco, 1, produto.UrlImagem);
carrinho = await carrinhoService.AddItem(idUsuario, itemCarrinho);
}
else
{
carrinho = await carrinhoService.GetCarrinho(idUsuario);
}
await CheckUserCounterData();
return(View(carrinho));
}
catch (BrokenCircuitException e)
{
logger.LogError(e, e.Message);
HandleBrokenCircuitException(catalogoService);
}
catch (Exception e)
{
logger.LogError(e, e.Message);
HandleException();
}
return(View());
}
public async Task AddItem_carrinho_invalid_model()
{
//arrange
var clienteId = "123";
ItemCarrinho input = new ItemCarrinho("004", "004", "produto 004", 45.67m, 4);
_carrinhoRepositoryMock
.Setup(c => c.AddCarrinhoAsync(clienteId, It.IsAny <ItemCarrinho>()))
.ThrowsAsync(new KeyNotFoundException());
var controller = new CarrinhoController(
_carrinhoRepositoryMock.Object,
_identityServiceMock.Object,
_serviceBusMock.Object);
controller.ModelState.AddModelError("ProdutoId", "Required");
//act
ActionResult <CarrinhoCliente> actionResult = await controller.AddItem(clienteId, input);
//assert
Assert.IsType <BadRequestObjectResult>(actionResult.Result);
}
public async Task Index_BrokenCircuitException()
{
//arrange
var clienteId = "cliente_id";
var produtos = GetFakeProdutos();
var testProduct = produtos[0];
catalogoServiceMock
.Setup(c => c.GetProduto(It.IsAny <string>()))
.ThrowsAsync(new BrokenCircuitException())
.Verifiable();
var itemCarrinho = new ItemCarrinho(testProduct.Codigo, testProduct.Codigo, testProduct.Nome, testProduct.Preco, 1, testProduct.UrlImagem);
carrinhoServiceMock
.Setup(c => c.AddItem(clienteId, It.IsAny <ItemCarrinho>()))
.ReturnsAsync(
new CarrinhoCliente(clienteId,
new List <ItemCarrinho>
{
itemCarrinho
}))
.Verifiable();
var controller = GetCarrinhoController();
SetControllerUser(clienteId, controller);
//act
var result = await controller.Index(testProduct.Codigo);
//assert
var viewResult = Assert.IsType <ViewResult>(result);
loggerMock.Verify(l => l.Log(LogLevel.Error, It.IsAny <EventId>(), It.IsAny <FormattedLogValues>(), It.IsAny <Exception>(), It.IsAny <Func <object, Exception, string> >()), Times.Once);
Assert.True(!string.IsNullOrWhiteSpace(controller.ViewBag.MsgServicoIndisponivel as string));
catalogoServiceMock.Verify();
}
public IActionResult PostNovoItemCarrinho([FromBody] ItemCarrinho itemCarrinho, string sessionId)
{
if (itemCarrinho == null)
{
return(BadRequest("Verifique o json informado no corpo do request."));
}
try
{
var carrinho = HttpContext.Session.GetObject <List <ItemCarrinho> >(sessionId);
if (carrinho == null)
{
carrinho = new List <ItemCarrinho>();
}
var itemCarrinhoAux = carrinho.Find(r => r.Id == itemCarrinho.Id);
if (itemCarrinhoAux != null)
{
itemCarrinhoAux.Quantidade += itemCarrinho.Quantidade;
}
else
{
carrinho.Add(itemCarrinho);
}
HttpContext.Session.SetObject(sessionId, carrinho);
return(Ok(carrinho));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void SelecionarItemPorId_Sucesso_True()
{
var carrinho = new Carrinho();
var itemCarrinho = new ItemCarrinho()
{
Produto = new Produto(),
Quantidade = 5
};
carrinho.AdicionarItem(itemCarrinho);
var itemResult = carrinho.SelecionarItemPorId(itemCarrinho.ItemCarrinhoId);
Assert.AreEqual(itemResult, itemCarrinho);
}
public void ForEachNoCarrinho_Sucesso_True()
{
var carrinho = new Carrinho();
var itemCarrinho = new ItemCarrinho()
{
Produto = new Produto(),
Quantidade = 5
};
var itemCarrinho2 = new ItemCarrinho()
{
Produto = new Produto(),
Quantidade = 5
};
var itemCarrinho3 = new ItemCarrinho()
{
Produto = new Produto(),
Quantidade = 5
};
carrinho.AdicionarItem(itemCarrinho);
carrinho.AdicionarItem(itemCarrinho2);
carrinho.AdicionarItem(itemCarrinho3);
IList<ItemCarrinho> listResult = new List<ItemCarrinho>();
foreach (var item in carrinho)
{
listResult.Add(item);
}
Assert.IsTrue(listResult.Count == 3);
Assert.IsTrue(listResult.Contains(itemCarrinho));
Assert.IsTrue(listResult.Contains(itemCarrinho2));
Assert.IsTrue(listResult.Contains(itemCarrinho3));
}
public void ItemCarrinho_ValorComDescontoPromocionalCorreto_TresPorDezReais_Sucesso_False()
{
var itemCarrinho = new ItemCarrinho()
{
Produto = new Produto()
{
Nome = "Sabonete",
Preco = 5,
TipoPromocao = TipoPromocao.TresPorDezReais
},
Quantidade = 3
};
Assert.IsTrue(itemCarrinho.ValorItemComDescontoPromocional == 10);
}
decimal Calcular(ItemCarrinho item) => item.Quantidade * 4 / 1000;
decimal Calcular(ItemCarrinho item)
{
var total = item.Quantidade * 0.4;
var pacoteDeTres = item.Quantidade / 3;
return total - pacoteDeTres * 0.2;
}
public void ItemCarrinhoDevePossuirProduto_Sucesso_False()
{
var itemCarrinho = new ItemCarrinho();
Assert.IsFalse(new ItemCarrinhoDevePossuirProdutoSpecification().IsSatisfiedBy(itemCarrinho));
}