public ResumoPedidoDto MontarPedido(MontagemPedidoDto montagemPedido)
{
var tamanhoPizza = _tamanhosPizzaRepository.GetAll()
.FirstOrDefault(x => x.Tamanho.ToUpper() == montagemPedido.TamanhoPizza.ToUpper());
if (tamanhoPizza == null)
{
throw new Exception($"O tamanho de pizza { montagemPedido.TamanhoPizza } informado não esta cadastrado!");
}
var saborPizza = _saboresPizzaRepository.GetAll()
.FirstOrDefault(x => x.Sabor.ToUpper() == montagemPedido.SaborPizza.ToUpper());
if (saborPizza == null)
{
throw new Exception($"O sabor de pizza { montagemPedido.SaborPizza } informado não esta cadastrado!");
}
var pedido = new Pedidos
{
TamanhosPizza = tamanhoPizza,
SaboresPizza = saborPizza,
Total = tamanhoPizza.Valor,
Tempo = tamanhoPizza.Tempo + saborPizza.TempoAdicional ?? 0,
Finalizado = false
};
_pedidoRepository.Add(pedido);
var resumoPedido = _mapper.Map <ResumoPedidoDto>(pedido);
return(resumoPedido);
}
async Task <int> IPedidoService.Incluir(Pedido pedido)
{
bool pedidoValido = pedido.PedidoValido();
if (!pedidoValido)
{
return(-1);
}
IEnumerable <int> IdsPizzas = pedido.Pizzas.Select(x => x.IdPizzaSabor1).Union(pedido.Pizzas.Where(x => x.IdPizzaSabor2 != null).Select(x => x.IdPizzaSabor2.Value));
ICollection <PizzaSabores> pizzas = await GetPizzas(IdsPizzas);
if (pizzas.Count != IdsPizzas.Count())
{
return(-2); // Id de pizza inexistente
}
bool clienteExiste = await _clienteRepository.ClienteExiste(pedido.IdCliente);
if (!clienteExiste)
{
Cliente newCliente = new Cliente(pedido.Endereco_Entrega);
Cliente cliente = await _clienteRepository.Add(newCliente);
pedido.SetCliente(cliente.Id);
}
pedido.CalcularValorTotal(pizzas);
pedido.Criar();
Pedido result = await _pedidoRepository.Add(pedido);
return(result.Id);
}
public void Post([FromBody] PedidoCreateRequestModel value) // RequestModel
{
Pedido pedido = new Pedido();
pedido.Sabor = _saborRepository.Find(value.Sabor);
pedido.SaborId = pedido.Sabor.Id;
pedido.Tamanho = _tamanhoRepository.Find(value.Tamanho);
pedido.TamanhoId = pedido.Tamanho.Id;
List <Personalizacao> personalizacoes = _personalizacaoRepository.GetPersonalizacoesPelosIds(value.Personalizacoes).ToList();
if (personalizacoes != null && personalizacoes.Count > 0)
{
foreach (Personalizacao item in personalizacoes)
{
PedidoPersonalizacao pedidoPersonalizacao = new PedidoPersonalizacao();
pedidoPersonalizacao.Personalizacao = new Personalizacao()
{
Id = item.Id,
Description = item.Description,
TempoAdicional = item.TempoAdicional,
ValorAdicional = item.ValorAdicional
};
pedidoPersonalizacao.Pedido = pedido;
pedidoPersonalizacao.Personalizacao.Pedidos.Add(pedidoPersonalizacao);
pedidoPersonalizacao.Pedido.Personalizacoes.Add(pedidoPersonalizacao);
_pedidoPersonalizacaoRepository.Add(pedidoPersonalizacao);
pedido.Personalizacoes.Add(pedidoPersonalizacao);
}
}
pedido.TempoPreparo = GetTempoPreparo(pedido, personalizacoes);
pedido.ValorTotal = GetValorTotal(pedido, personalizacoes);
_pedidoRepository.Add(pedido); // Insertion
}
public async Task <IActionResult> CriarPedido([FromBody] CriarPedidoCommand comand)
{
_pedidoRepository.Add(comand.Map());
var result = await _pedidoRepository.UnitOfWork.Commit();
return(Ok());
}
public Task <CustomResponse> Handle(AdicionarPedidoCommand command, CancellationToken cancellationToken)
{
var respostaCustomizada = new CustomResponse();
if (!command.EhValido())
{
var errosDeValidacao = new List <string>();
foreach (var erro in command.ValidationResult.Errors)
{
errosDeValidacao.Add(erro.ErrorMessage);
}
respostaCustomizada.AdicionarErro(errosDeValidacao);
return(Task.FromResult(respostaCustomizada));
}
var pedido = new Models.Movimento.Pedido(command.Numero, command.ClienteId);
pedidoRepository.Add(pedido);
if (!unitOfWork.Commit())
{
respostaCustomizada = new CustomResponse(mensagem: "Erro ao adicionar.");
respostaCustomizada.AdicionarErro(new List <string> {
"Erro ao adicionar o pedido."
});
return(Task.FromResult(respostaCustomizada));
}
respostaCustomizada = new CustomResponse(ResponseStatus.Sucesso, "Pedido cadastrado com sucesso.");
return(Task.FromResult(respostaCustomizada));
}
public async Task <IActionResult> Post(Pedido pedido)
{
try
{
foreach (var item in pedido.PedidoItem)
{
item.Produto.Estoque -= item.Quantidade;
_produtoRepository.Update(item.Produto);
item.Produto = null;
}
await _pedidoRepository.Add(pedido);
await _uow.Commit();
return(CreatedAtAction("Post", await Get(pedido.Id)));
}
catch (Exception ex)
{
await _uow.Rollback();
return(BadRequest(ex));
}
}
public void GerarPedido(CarrinhoEntity carrinho)
{
var pedido = new PedidoEntity();
pedido.IdUsuario = carrinho.IdUsuario;
pedido.Livros = carrinho.Livros;
_pedidoRepository.Add(pedido);
_carrinhoRepository.Delete(carrinho);
}
public void Save(Pedido Pedido)
{
try
{
dbPedido.Add(Pedido);
}
catch (Exception ex)
{
throw new Exception($"Erro ao salvar Pedido: {ex.Message}.");
}
}
private async Task SalvarPedido(Pedido pedido, IEnumerable <ItemPedido> itens)
{
await _pedidoRepository.BeginTransactionAsync();
_pedidoRepository.Add(pedido);
await _pedidoRepository.UnitOfWork.SaveChangesAsync();
_pedidoRepository.AddItensPedido(pedido.Id, itens);
await _pedidoRepository.UnitOfWork.SaveChangesAsync();
await _pedidoRepository.CommitTransactionAsync();
}
/// <summary>
/// Adiciona pedidos aleatorio para teste
/// </summary>
public void AddPedidos()
{
var ultimoPedidos = _pedidoRepository.GetListAll().OrderByDescending(x => x.Id).ToList()[0];
var pedidos = new List <Pedido>();
var rng = new Random();
var idDoPedido = ultimoPedidos.Id;
for (int i = 0; i < 80; i++)
{
var data = DateTime.Now.AddDays(rng.Next(-20, 1));
var produtos = new List <Produto>();
for (int i2 = 0; i2 < rng.Next(2, 4); i2++)
{
var produtoAdd = new Produto
{
PedidoId = idDoPedido + 1,
Nome = $"Tv LED Cod - {rng.Next(40, 50)}",
Descricao = $"Tv LED Cod - {rng.Next(2000, 9000)} Samsung",
Valor = Convert.ToDecimal(rng.Next(1220, 2245))
};
produtos.Add(produtoAdd);
}
var equipeAdd = new Equipe
{
PedidoId = idDoPedido + 1,
Nome = $"Equipe Setor - {rng.Next(40, 50)}",
Descricao = $"Equipe {rng.Next(2000, 9000)} atendimento especial",
PlacaDoVeiculo = $"ABC-{rng.Next(2000, 9000)}"
};
var pedidoAdd = new Pedido
{
DataDeCriacao = data,
DataDaEntregaRealizada = data.AddDays(2),
EnderecoEntregaRealizada = $"Rua {rng.Next(1, 20)}, + Numero {rng.Next(50, 200)} Sao Paulo",
Equipe = equipeAdd,
Produtos = produtos
};
_pedidoRepository.Add(pedidoAdd);
idDoPedido++;
}
}
public async Task <Guid> Handle(CriarPedidoCommand request, CancellationToken cancellationToken)
{
try
{
if (!request.IsValid())
{
ValidationErrors(request);
return(await Task.FromResult(Guid.Empty));
}
var comanda = _comandaRepository.GetById(request.IDComanda);
var garcom = _garcomRepository.GetById(request.IDGarcom);
var pedido = new Pedido
{
Id = GeradorGuidService.GetNexGuid(),
DataPedido = DateTime.Now,
IDComanda = comanda.Id,
Comanda = comanda,
IDGarcom = garcom.Id,
Garcom = garcom,
Situacao = SituacaoPedido.Aberto,
PedidoProdutos = new List <PedidoProduto>()
};
request.Produtos.ForEach(c =>
{
var pedidoProduto = new PedidoProduto
{
Id = GeradorGuidService.GetNexGuid(),
Produto = _produtoRepository.GetById(c.IDProduto),
IDProduto = c.IDProduto,
Quantidade = c.Quantidade,
IDPedido = c.IDPedido,
};
pedidoProduto.CalcularValorTotal();
pedido.PedidoProdutos.Add(pedidoProduto);
});
_pedidoRepository.Add(pedido);
return(await Task.FromResult(pedido.Id));
}
catch (Exception ex)
{
await Mediator.Publish(new DomainNotification(request.MessageType, $"Erro: {ex.Message}"), cancellationToken);
return(await Task.FromResult(Guid.Empty));
}
}
public async Task <Response.Pedido> Add(Request.Pedido entity)
{
if (!IsParameterValid(entity))
{
throw new InvalidParametersException <IPedidoAppService>();
}
var pedido = await pedidoRepository.Add(entity.ConvertToData());
await Salvar();
return(new Response.Pedido());
}
public void Confirmar(PedidoDTO pedidoDto, out int numeroPedido)
{
var pedido = _pedidoMapper.Map(pedidoDto);
pedido.Guid = Guid.NewGuid();
pedido.CodigoCliente = ObterCodigoCliente(pedidoDto);
pedido.PedidoItemSet = ObterPedidoItemSet(pedidoDto);
_pedidoRepository.Add(pedido);
_pedidoRepository.Save();
NotificarFornecedor(pedido);
numeroPedido = pedido.Codigo;
}
public async Task <IActionResult> PostPedido([FromBody] SavePedidoResource pedidoResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var pedido = mapper.Map <SavePedidoResource, Pedido>(pedidoResource);
pedido.DataPedido = DateTime.Now;
repository.Add(pedido);
await unitOfWork.CompleteAsync();
pedido = await repository.GetPedido(pedido.PedidoId);
var result = mapper.Map <Pedido, PedidoResource>(pedido);
return(Ok(result));
}
public async Task <ResultEntity <Pedido> > Create(Pedido pedido)
{
try
{
var _pedido = await _repository.GetByCodigo(pedido.CodPedido);
if (_pedido != null)
{
return(ResultEntity <Pedido> .Fail(pedido, $"Já existe um pedido com esse código - {pedido.CodPedido}"));
}
if (!pedido.ItensPedido.Any())
{
throw new ArgumentNullException(nameof(pedido), "Necessário pelo menos 1 item de pedido.");
}
if (pedido.ItensPedido.Count() > 10)
{
throw new ArgumentNullException(nameof(pedido.ItensPedido), "Máximo de items por pedido é 10");
}
var pizzas = await _pizzaRepository.GetAll();
if (!pizzas.Any())
{
throw new ArgumentNullException(nameof(pedido.ItensPedido), "Nenhuma pizza cadastrada!");
}
pedido.ItensPedido = (from item in pedido.ItensPedido
select new ItemPedido().AtualizarValorUnitario(item, pizzas.ToList())).ToList();
pedido = await _repository.Add(pedido);
return(ResultEntity <Pedido> .Success(pedido));
}
catch (Exception e)
{
return(ResultEntity <Pedido> .Fail(pedido, $"Ocorreu algum erro na criação do pedido - {e.Message}"));
}
}
public async Task <bool> Handle(AdicionarItemPedidoCommand message, CancellationToken cancellationToken)
{
if (!ValidateCommand(message))
{
return(false);
}
var pedido = await _pedidoRepository.GetPedidoRascunhoByClienteId(message.ClienteId);
var pedidoItem = new PedidoItem(message.ProdutoId, message.Nome, message.Quantidade, message.ValorUnitario);
if (pedido == null)
{
pedido = Pedido.PedidoFactory.NewPedidoRascunho(message.ClienteId);
pedido.AddItem(pedidoItem);
_pedidoRepository.Add(pedido);
pedido.AddEvent(new PedidoRascunhoIniciadoEvent(message.ClienteId, message.ProdutoId));
}
else
{
var pedidoItemExistente = pedido.PedidoItemExistente(pedidoItem);
pedido.AddItem(pedidoItem);
if (pedidoItemExistente)
{
_pedidoRepository.UpdateItem(pedido.PedidoItems.FirstOrDefault(p => p.ProdutoId == pedidoItem.ProdutoId));
}
else
{
_pedidoRepository.AddItem(pedidoItem);
}
pedido.AddEvent(new PedidoAtualizadoEvent(pedido.ClienteId, pedido.Id, pedido.ValorTotal));
}
pedido.AddEvent(new PedidoItemAdicionadoEvent(pedido.ClienteId, pedido.Id, message.ProdutoId, message.Nome, message.ValorUnitario, message.Quantidade));
return(await _pedidoRepository.UnitOfWork.Commit());
}
public PedidoViewModel Add(PedidoViewModel pedidoViewModel)
{
//string pedidoViewModel = "Manhã, 1, 2, 3, 3, 3";
if (string.IsNullOrEmpty(pedidoViewModel.Entrada))
{
pedidoViewModel.Saida = "erro";
pedidoViewModel.Errors.Add(new PedidoErrorViewModel()
{
Message = "Pedido não pode ser vazio ", Name = "Entrada"
});
pedidoViewModel.HistoricoPedidos = _pedidoRepository.GetAll();
return(pedidoViewModel);
}
var order = pedidoViewModel.Entrada.Split(",");
//verificar se período existe;
var entradaPeriodoDescricao = order[0].ToLower();
//buscando o periodo igual ao informado
var periodo = _periodoRepository.GetAll().FirstOrDefault(x => x.Descricao.ToLower() == entradaPeriodoDescricao);
if (periodo == null)
{
pedidoViewModel.Saida = "erro";
pedidoViewModel.Errors.Add(new PedidoErrorViewModel()
{
Message = "Perido Invalido", Name = "Entrada"
});
pedidoViewModel.HistoricoPedidos = _pedidoRepository.GetAll();
return(pedidoViewModel);
}
//var digitos = string.Join("", order.Skip(1)).ToCharArray();
//if (!digitos.All(x=> char.IsDigit(x)))
//{
// pedidoViewModel.Saida = "erro";
// pedidoViewModel.Errors.Add(new PedidoErrorViewModel() { Message = "Perido Invalido", Name = "Entrada" });
// pedidoViewModel.HistoricoPedidos = _pedidoRepository.GetAll();
// return pedidoViewModel;
//}
var itens = order.Skip(1).Select(x => Convert.ToInt32(x));
if (!itens.Any())
{
pedidoViewModel.Saida = "erro";
pedidoViewModel.Errors.Add(new PedidoErrorViewModel()
{
Message = "Adicione ao menos um item", Name = "Entrada"
});
pedidoViewModel.HistoricoPedidos = _pedidoRepository.GetAll();
return(pedidoViewModel);
}
var itensCadastrados = _itemPratoRepository.GetAll();
int itemNaoEncontrado = itens.FirstOrDefault(x => !itensCadastrados.Any(y => y.Id == x));
if (itemNaoEncontrado > 0)
{
pedidoViewModel.Saida = "erro";
pedidoViewModel.Errors.Add(new PedidoErrorViewModel()
{
Message = $"Item {itemNaoEncontrado} não encontrado.", Name = "Entrada"
});
pedidoViewModel.HistoricoPedidos = _pedidoRepository.GetAll();
return(pedidoViewModel);
}
var(success, saida) = GetSaidaPedido(periodo, itens);
pedidoViewModel.Saida = saida;
if (success)
{
_pedidoRepository.Add(new Pedido
{
DataPedido = DateTime.Now,
Entrada = pedidoViewModel.Entrada,
Saida = pedidoViewModel.Saida
});
}
else
{
pedidoViewModel.Errors.Add(new PedidoErrorViewModel()
{
Name = "Entrada",
Message = "Itens não atende os requisitos"
});
}
pedidoViewModel.HistoricoPedidos = _pedidoRepository.GetAll();
return(pedidoViewModel);
}
public void Add(Pedido model)
{
_pedidoRepository.Add(model);
_unitOfWork.Commit();
}
public void Add(PedidoCreateDTO pedidoDTO)
{
var pedido = _mapper.Map <PedidoCreateDTO, Pedido>(pedidoDTO);
_pedidoRepository.Add(pedido);
}
public async Task <Guid> Handle(CriarPedidoCommand request, CancellationToken cancellationToken)
{
var pedido = new Pedido();
var garcom = _garcomRepository.GetEntityById(request.IDGarcom);
if (garcom == null)
{
request.AddNotification("Garcom", "Garcom não encontrado no banco de dados.");
}
var cliente = _clienteRepository.GetEntityById(request.IDCliente);
if (cliente == null)
{
request.AddNotification("Cliente", "Cliente não encontrado no banco de dados.");
}
var comanda = _comandaRepository.GetEntityById(request.IDComanda);
if (comanda == null)
{
request.AddNotification("Comanda", "Comanda não encontrado no banco de dados.");
}
else
{
var ultimoHistoricoPedidoComanda = await _mediator.Send(new ObterUltimoHistoricoPedidoComandaQuery(comanda.Id));
if (ultimoHistoricoPedidoComanda != null)
{
if (!SituacaoPedido.SituacoesPermiteAberturaComanda.Any(situacao => situacao == ultimoHistoricoPedidoComanda.Situacao))
{
request.AddNotification("Comanda", $"Comanda não pode ser aberta devido ao ultimo pedido estar com a situação({ultimoHistoricoPedidoComanda.Situacao}).");
}
}
}
pedido = new Pedido(garcom, comanda, cliente);
request.Produtos.ToList().ForEach(produtoPedido => pedido.AdicionarProduto(produtoPedido));
if (pedido.Invalid || request.Invalid)
{
pedido.AddNotifications(request.Notifications);
await _mediator.Publish(new DomainNotification
{
Erros = pedido.Notifications
}, cancellationToken);
return(await Task.FromResult(Guid.Empty));
}
var historicoPedido = new HistoricoPedido(Enums.EnumSituacaoPedido.Aberto, pedido.Id);
pedido.AdicionarHistorico(historicoPedido);
_pedidoRepository.Add(pedido);
return(await Task.FromResult(pedido.Id));
}
public Pedido Add(Pedido cliente)
{
cliente.Validar();
return(_PedidoRepository.Add(cliente));
}
public void Add(string discos)
{
_repository.Add(discos);
}
public ActionResult <Pedido> Cadastrar(Pedido model)
{
try
{
if (model.Itens == null || model.Itens.Count == 0 || model.Itens.Count > 10)
{
return(BadRequest("Um pedido pode ter no mínimo uma pizza e no máximo 10."));
}
if (model.CodCliente != 0)
{
var endereco = _clienteRepository.Get(model.CodCliente);
if (endereco != null)
{
model.Bairro_Entrega = endereco.Bairro;
model.Cidade_Entrega = endereco.Cidade;
model.Complemento_Entrega = endereco.Complemento;
model.Estado_Entrega = endereco.Estado;
model.Logradouro_Entrega = endereco.Logradouro;
model.Numero_Entrega = endereco.Numero;
model.NomeCliente = endereco.Nome;
model.Email = endereco.Email;
model.Telefone = endereco.Telefone;
}
else
{
return(BadRequest("O cliente informado, não foi encontrado;"));
}
}
#region calcula Preço
decimal valorTotal = 0;
foreach (var item in model.Itens)
{
if (item.Pizza == null || item.Pizza.Count == 0)
{
return(BadRequest("Nenhuma pizza foi adicionada!"));
}
if (item.Pizza.Count > 2)
{
return(BadRequest("Cada pizza deve ter no mínimo dois sabores!"));
}
foreach (var subItem in item.Pizza)
{
var pizza = _pizzaRepository.Get(subItem.CodPizza);
subItem.Nome = pizza.Nome;
if (item.Pizza.Count == 1)
{
valorTotal += pizza.Preco;
subItem.Preco = pizza.Preco;
}
else
{
var valorItem = (pizza.Preco / 2);
valorTotal += valorItem;
subItem.Preco = valorItem;
}
}
}
model.PrecoTotal = valorTotal;
#endregion
model.CodPedido = _pedidoRepository.Add(model).CodPedido;
foreach (var item in model.Itens)
{
item.CodPedido = model.CodPedido;
item.CodPedidoItem = _pedidoItemRepository.Add(item).CodPedidoItem;
foreach (var subItem in item.Pizza)
{
subItem.CodPedidoItem = item.CodPedidoItem;
subItem.CodSubItem = _subItemRepository.Add(subItem).CodSubItem;
}
}
return(Ok(model));
}
catch (Exception e)
{
return(BadRequest());
}
}
public async Task PostAsync(PedidoRequestDto dto, int usuarioId)
{
if (await Task.Run(() => !_usuarioBusiness.Exists(x => x.UsuarioId == usuarioId)))
{
throw new ArgumentException("Usuário não encontrado");
}
if (await Task.Run(() => !_formaPagamentoBusiness.Exists(x => x.FormaPagamentoId == dto.FormaPagamentoId)))
{
throw new ArgumentException("Forma de Pagamento não encontrada");
}
if (await Task.Run(() => !_usuarioEnderecoBusiness.Exists(x => x.UsuarioEnderecoId == dto.UsuarioEnderecoId)))
{
throw new ArgumentException("Endereço de entrega não encontrado");
}
foreach (var produto in dto.Itens)
{
var model = _produtoBusiness.Get(x => x.ProdutoId == produto.ProdutoId);
if (model == null)
{
throw new ArgumentException("Produto não encontrado");
}
else
{
if (model.Ativo == false || model.EmEstoque == false)
{
throw new ArgumentException("Produto {0} indisponível", model.Nome);
}
}
}
using (var transaction = DbContext.Database.BeginTransaction())
{
try
{
var obj = new Pedido()
{
UsuarioId = usuarioId,
ValorTotal = dto.ValorTotal,
FormaPagamentoId = dto.FormaPagamentoId,
Data = DateTime.Now
};
_pedidoRepository.Add(obj);
var endereco = _usuarioEnderecoBusiness.Get(dto.UsuarioEnderecoId);
_pedidoEntregaRepository.Add(new PedidoEntrega()
{
PedidoId = obj.PedidoId,
Logradouro = endereco.Logradouro,
Numero = endereco.Numero,
Complemento = endereco.Complemento,
Cidade = endereco.Cidade,
Bairro = endereco.Bairro,
Estado = endereco.Estado,
CEP = endereco.CEP
});
foreach (var produto in dto.Itens)
{
var model = _produtoBusiness.Get(produto.ProdutoId);
var item = new PedidoItem()
{
PedidoId = obj.PedidoId,
ProdutoId = produto.ProdutoId,
Quantidade = produto.Quantidade,
PrecoUnitario = produto.PrecoUnitario,
ValorTotal = produto.Quantidade * produto.PrecoUnitario
};
_pedidoItemBusiness.Add(item);
var itemFornecedor = new PedidoItemFornecedor()
{
PedidoItemId = item.PedidoItemId,
CodPedidoItemFornec = GerarPedidoFornecedor(model.FornecedorId, obj.PedidoId),
FornecedorId = model.FornecedorId,
UltimaAtualizacao = DateTime.Now,
StatusId = 1
};
_pedidoItemFornecedorBusiness.Add(itemFornecedor);
}
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
}
}