public async Task <IActionResult> AdicionarItem(Guid id, int quantidade)
{
var produto = await _produtoAppService.ObterPorId(id);
if (produto == null)
{
return(BadRequest());
}
if (produto.QuantidadeEstoque < quantidade)
{
TempData["Erro"] = "Produto com estoque insuficiente";
return(RedirectToAction("ProdutoDetalhe", "Vitrine", new { id }));
}
var command = new AdicionarItemPedidoCommand(ClienteId, produto.Id, produto.Nome, quantidade, produto.Valor);
await _mediatrHandler.EnviarComando(command);
if (OperacaoValida())
{
return(RedirectToAction("Index"));
}
TempData["Erros"] = ObterMensagensErro();
return(RedirectToAction("ProdutoDetalhe", "Vitrine", new { id }));
}
public async Task <bool> Handle(AtualizarSituacaoDroneCommand message, CancellationToken cancellationToken)
{
if (!ValidarComando(message))
{
return(false);
}
var droneItinerarios = _droneItinerarioQueries.ObterDronesIndisponiveis().Result.ToList();
foreach (var droneItinerario in droneItinerarios)
{
if (droneItinerario.StatusDrone == EnumStatusDrone.Carregando)
{
if (DateTime.Now.Subtract(droneItinerario.DataHora).TotalMinutes >= droneItinerario.Drone.Carga)
{
await _mediatr.EnviarComando(new AdicionarDroneItinerarioCommand(DateTime.Now, droneItinerario.Drone.Id, EnumStatusDrone.Disponivel));
}
}
else if (droneItinerario.StatusDrone == EnumStatusDrone.EmTransito)
{
var pedidos = await _pedidoQueries.ObterPedidosEmTransitoPorDrone(droneItinerario.Drone.Id);
int tempoEntrega = CalcularTempoTotalEntregaEmMinutos(pedidos, droneItinerario.Drone);
if (droneItinerario.DataHora.AddMinutes(tempoEntrega) <= DateTime.Now)
{
int limiteAutonomiaParaRecarga = Convert.ToInt32(Math.Ceiling(droneItinerario.Drone.Autonomia * 0.2));
if (droneItinerario.Drone.AutonomiaRestante <= limiteAutonomiaParaRecarga)
{
await _mediatr.EnviarComando(new AdicionarDroneItinerarioCommand(DateTime.Now, droneItinerario.Drone.Id, EnumStatusDrone.Carregando));
}
else
{
await _mediatr.EnviarComando(new AdicionarDroneItinerarioCommand(DateTime.Now, droneItinerario.Drone.Id, EnumStatusDrone.Disponivel));
}
foreach (var pedido in pedidos)
{
await _mediatr.EnviarComando(new AtualizarSituacaoPedidoCommand(pedido.Id, EnumStatusPedido.Entregue));
}
}
}
}
return(true);
}
public async Task Handle(PagementoPedidoProcessadoEvent message, CancellationToken cancellationToken)
{
if (message.SituacaoPagamento == SituacaoPagamento.Aguardando)
{
return;
}
var statusPedido = message.SituacaoPagamento == SituacaoPagamento.Autorizado ? EnumStatusPedido.AguardandoEntregador : EnumStatusPedido.PagamentoRejeitado;
await _mediatr.EnviarComando(new AtualizarSituacaoPedidoCommand(message.EntityId, statusPedido));
}
public async Task <IActionResult> Post([FromBody] AdicionarClienteViewModel clienteView)
{
var sucesso = await _mediatr.EnviarComando(_mapper.Map <AdicionarClienteCommand>(clienteView));
if (!sucesso)
{
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> PostDrone(AdicionarDroneViewModel droneViewModel)
{
var sucesso = await _mediatr.EnviarComando(_mapper.Map <AdicionarDroneCommand>(droneViewModel));
if (!sucesso)
{
return(BadRequest());
}
return(Ok());
}
public async Task Handle(PagamentoCartaoProcessadoEvent message)
{
if (message.SituacaoPagamento == SituacaoPagamento.Aguardando)
{
return;
}
var statusPedido = message.SituacaoPagamento == SituacaoPagamento.Autorizado ? EnumStatusPedido.AguardandoEntregador : EnumStatusPedido.PagamentoRejeitado;
await _mediatr.EnviarComando(new AtualizarSituacaoPedidoCommand(message.AggregateRoot, statusPedido));
}
public async Task <IActionResult> AdicionarPedido(AdicionarPedidoViewModel pedidoViewModel)
{
var user = await _usuarioQueries.ObterPorNome(pedidoViewModel.usuario);
if (user == null)
{
return(BadRequest());
}
var cliente = await _clienteQueries.ObterPorId(user.ClienteId);
var retorno = await _mediator.EnviarComando(new AdicionarPedidoCommand(cliente.Id, pedidoViewModel.Valor, pedidoViewModel.Peso, DateTime.Now, pedidoViewModel.Bandeira, pedidoViewModel.NumeroCartao, pedidoViewModel.MesVencimento, pedidoViewModel.AnoVencimento));
if (!retorno)
{
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> PagamentoCartaoPost(AdicionarPagamentoCartaoViewModel viewModel)
{
// TODO: Verificar como retornar motivo da rejeição do pagamento a partir do service pra não precisar validar aqui, apenas no service.
var enviado = await _bus.EnviarComando(_mapper.Map <AdicionarPagamentoCartaoCommand>(viewModel));
if (!enviado)
{
return(BadRequest());
}
return(Ok());
}
public async Task <ActionResult <Drone> > PostDrone([FromBody] Drone drone)
{
var command = new AdicionarDroneCommand(autonomia: drone.Autonomia, capacidade: drone.Capacidade, velocidade: drone.Velocidade, autonomiaRestante: drone.AutonomiaRestante, carga: drone.Carga);
var enviado = await _bus.EnviarComando(command);
if (!enviado)
{
return(BadRequest());
}
return(CreatedAtAction("GetDrone", new { id = drone.Id }, drone));
}
public async Task Handle(DroneAutonomiaBaixaEvent messagem, CancellationToken cancellationToken)
{
var drone = await _droneRepository.GetByIdAsync(messagem.Id);
if (drone == null)
{
return;
}
var command = new CarregarBareriaDroneCommand(capacidade: drone.Capacidade, velocidade: drone.Velocidade, autonomia: drone.Autonomia, autonomiaRestante: drone.AutonomiaRestante, carga: drone.Carga)
{
};
await _bus.EnviarComando(command);
}
public async Task CheckOut()
{
var pedidos = await _pedidoQueries.ObterPedidosAguardandoEntregador();
var entregas = new List <Entrega>();
foreach (var item in pedidos)
{
var drone = await _droneQueries.ObterDroneDisponiveil();
var listaCheckout = pedidos.Where(p => p.Peso <= drone.Capacidade);
listaCheckout = listaCheckout?.Where(p => drone.AutonomiaRestante >= new Localizacao()
{
Latitude = (double)p.Latitude, Longitude = (double)p.Longitude
}.CalcularDistanciaEmKilometros() * 2);
foreach (var checkout in listaCheckout)
{
var tempoPercurso = Convert.ToInt32(new Localizacao()
{
Latitude = (double)checkout.Latitude, Longitude = (double)checkout.Longitude
}.CalcularDistanciaEmKilometros() * 2);
if ((drone.Capacidade >= checkout.Peso) && (drone.AutonomiaRestante >= tempoPercurso))
{
entregas.Add(new Entrega()
{
PedidoId = checkout.Id, DroneId = drone.Id, DataPrevisao = DateTime.Now.AddMinutes(tempoPercurso / 2)
});
var command = new EntregarPedidoCommand(dataPrevisao: DateTime.Now.AddMinutes(tempoPercurso / 2), checkout.Id, statusDrone: EStatusDrone.EmTransito, statusPedido: EStatusPedido.EmTransito);
var saiuParaEntrega = await _bus.EnviarComando(command);
if (saiuParaEntrega)
{
drone.Capacidade -= checkout.Peso;
drone.AutonomiaRestante -= tempoPercurso;
}
}
else
{
break;
}
}
var droneAlterado = await _droneRepository.GetByIdAsync(drone.Id);
droneAlterado.AutonomiaRestante = drone.AutonomiaRestante;
await _droneRepository.UpdateAsync(droneAlterado);
}
}
public async Task <ActionResult> PostAsync([FromBody] PedidoViewModel pedido)
{
var command = new AdicionarPedidoCommand(peso: pedido.Peso, latitude: pedido.Latitude, longitude: pedido.Longitude);
var enviado = await _bus.EnviarComando(command);
if (!enviado)
{
return(BadRequest());
}
await _bus.PublicarEvento(new SolicitarEntregaEvent(command.Id));
return(CreatedAtAction("GetPedido", new { Sucess = true, command.Id }));
}
public async Task Handle(PagamentoCartaoAdicionadoEvent message, CancellationToken cancellationToken)
{
var pagamentoCartao = await _pagamentoQueries.ObterPorId(message.EntityId);
if (pagamentoCartao == null)
{
return;
}
var body = _mapper.Map <PagamentoRequestDTO>(pagamentoCartao);
using (HttpClient client = new HttpClient())
{
var response = await client.PostAsync("https://5f542997e5de110016d51dec.mockapi.io/v1/pagamento", new StringContent(JsonConvert.SerializeObject(body), Encoding.UTF8, "application/json"));
if (response.IsSuccessStatusCode)
{
var objResponse = JsonConvert.DeserializeObject <PagamentoResponseDTO>(await response.Content.ReadAsStringAsync());
objResponse.PagamentoId = pagamentoCartao.Id;
await _bus.EnviarComando(_mapper.Map <AtualizarSituacaoPagamentoCartaoCommand>(objResponse));
}
}
}
public async Task Handle(ClienteAdiconadoEvent message, CancellationToken cancellationToken)
{
await _mediatr.EnviarComando(new AdicionarUsuarioCommand(message.Nome, message.Senha, message.EntityId, "User"));
}
public async Task Handle(DroneAdicionadoEvent message, CancellationToken cancellationToken)
{
await _mediatr.EnviarComando(new AdicionarDroneItinerarioCommand(DateTime.Now, message.AggregateRoot, EnumStatusDrone.Disponivel));
}
public async Task <bool> Handle(DespacharPedidoCommand message, CancellationToken cancellationToken)
{
if (!ValidarComando(message))
{
return(false);
}
var pedidos = _pedidoQueries.ObterPedidosEmAberto().Result.ToList();
if (!pedidos.Any())
{
return(false);
}
var dronesDisponiveis = _droneItinerarioQueries.ObterDronesDisponiveis().Result.ToList();
if (!dronesDisponiveis.Any())
{
return(false);
}
var pedidosEntregar = new List <PedidoViewModel>();
var pedidosDistribuidos = new List <PedidoViewModel>();
foreach (var drone in dronesDisponiveis)
{
pedidosEntregar.Clear();
double distanciaTrajeto = 0;
double distanciaRetorno = 0;
double distanciaPercorrida = 0;
double distanciaTotal = 0;
int tempoTrajetoCompleto = 0;
var capacidadeDisponivel = drone.Capacidade;
var autonomiaDisponivel = drone.AutonomiaRestante;
foreach (var pedido in pedidos)
{
if (pedidosDistribuidos.Contains(pedido))
{
continue;
}
Localizacao localizacaoOrigem;
if (pedido.Peso > capacidadeDisponivel)
{
continue;
}
if (pedidosEntregar.Any())
{
localizacaoOrigem = new Localizacao(pedidosEntregar.Last().Cliente.Latitude, pedidosEntregar.Last().Cliente.Longitude);
}
else
{
localizacaoOrigem = message.LocalizacaoLoja;
}
var localizacaoCliente = new Localizacao(pedido.Cliente.Latitude, pedido.Cliente.Longitude);
distanciaTrajeto = localizacaoOrigem.CalcularDistanciaEmKilometros(localizacaoCliente);
distanciaRetorno = localizacaoCliente.CalcularDistanciaEmKilometros(localizacaoOrigem);
distanciaTotal = distanciaPercorrida + distanciaTrajeto + distanciaRetorno;
tempoTrajetoCompleto = distanciaTotal.CalcularTempoTrajetoEmMinutos(drone.Velocidade);
if (tempoTrajetoCompleto <= drone.AutonomiaRestante)
{
pedidosEntregar.Add(pedido);
distanciaPercorrida += distanciaTrajeto;
capacidadeDisponivel -= pedido.Peso;
autonomiaDisponivel = drone.AutonomiaRestante - tempoTrajetoCompleto;
}
// se não cabe mais, nao precisa verificar os demais pedidos
if (capacidadeDisponivel <= 0 || tempoTrajetoCompleto >= drone.AutonomiaRestante)
{
break;
}
if (!pedidosEntregar.Any())
{
continue;
}
await _mediatr.EnviarComando(new AtualizarAutonomiaDroneCommand(drone.Id, autonomiaDisponivel));
await _mediatr.EnviarComando(new AdicionarDroneItinerarioCommand(DateTime.Now, drone.Id, EnumStatusDrone.EmTransito));
foreach (var pedidoentregar in pedidosEntregar)
{
var pedidoDespachado = await _pedidoRepository.ObterPorId(pedidoentregar.Id);
if (pedido == null)
{
return(false);
}
var entregador = await _droneRepository.ObterPorId(drone.Id);
if (entregador == null)
{
return(false);
}
pedidoDespachado.Drone = entregador;
pedidoDespachado.InformarStatus(EnumStatusPedido.EmTransito);
pedidoDespachado.AdicionarEvento(new PedidoDespachadoEvent()
{
AggregateRoot = pedido.Id
});
await _pedidoRepository.Atualizar(pedidoDespachado);
await _pedidoRepository.UnitOfWork.Commit();
pedidos.Remove(pedidoentregar);
}
}
}
return(true);
}
public async Task Handle(PedidoEstoqueRejeitadoEvent message, CancellationToken cancellationToken)
{
await _mediatrHandler.EnviarComando(new CancelarProcessamentoPedidoCommand(message.PedidoId, message.ClienteId));
}
public async Task Handle(PedidoEstoqueRejeitadoEvent notification, CancellationToken cancellationToken)
{
// Cancelar o processamento do pedido - retornar erro para o cliente
await _mediatrHandler.EnviarComando(
new CancelarProcessamentoPedidoCommand(notification.PedidoId, notification.ClienteId));
}
