Example #1
0
        public async Task <ActionResult> PostDrone(AdicionarDroneViewModel droneViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState.Values.Select(x => x.Errors)));
            }

            var drone = new Drone()
            {
                Velocidade        = droneViewModel.Velocidade,
                Autonomia         = droneViewModel.Autonomia,
                AutonomiaRestante = droneViewModel.Autonomia,
                Carga             = droneViewModel.Carga,
                Capacidade        = droneViewModel.Capacidade
            };

            bool result = await _droneService.Insert(drone);

            if (result)
            {
                var droneItinerario = new DroneItinerario
                {
                    DataHora    = System.DateTime.Now,
                    Drone       = drone,
                    DroneId     = drone.Id,
                    StatusDrone = EnumStatusDrone.Disponivel
                };

                await _droneItinerarioService.Insert(droneItinerario);
            }

            return(CreatedAtAction("GetDrone", new { id = drone.Id }, drone));
        }
        public async Task <bool> Insert(DroneItinerario droneItinerario)
        {
            _context.Entry(droneItinerario.Drone).State = EntityState.Unchanged;

            _context.DroneItinerario.Add(droneItinerario);
            return(await _context.SaveChangesAsync() > 0);
        }
Example #3
0
        public async Task <ActionResult <IEnumerable <SituacaoDroneDTO> > > GetDrone()
        {
            var drones = _unitOfWork.Drones.GetAll();

            IList <SituacaoDroneDTO> situacaoDrones = new List <SituacaoDroneDTO>();

            foreach (var drone in drones)
            {
                SituacaoDroneDTO situacaoDrone = new SituacaoDroneDTO();
                situacaoDrone.Drone = drone;

                DroneItinerario droneItinerario = _unitOfWork.DroneItinerario.GetAll().Where(i => i.DroneId == drone.Id).FirstOrDefault();

                if (droneItinerario == null)
                {
                    situacaoDrone.StatusDrone = EnumStatusDrone.Disponivel.ToString();
                }
                else
                {
                    situacaoDrone.StatusDrone = droneItinerario.StatusDrone.ToString();
                }

                var pedidos = _unitOfWork.Pedidos.GetAll().Where(p => p.Drone != null && p.Status != EnumStatusPedido.Entregue && p.Drone.Id == drone.Id).ToList();

                situacaoDrone.Pedidos = pedidos;

                situacaoDrones.Add(situacaoDrone);
            }

            return(Ok(situacaoDrones));
        }
        public async Task <DroneItinerario> Update(DroneItinerario droneItinerario)
        {
            _context.DroneItinerario.Update(droneItinerario);
            await _context.SaveChangesAsync();

            return(droneItinerario);
        }
        public async Task <DroneItinerario> Update(DroneItinerario droneItinerario)
        {
            //bool tracking = _context.ChangeTracker.Entries<DroneItinerario>().Any(x => x.Entity.Id == droneItinerario.Id);

            //if (!tracking)
            //    _context.DroneItinerario.Update(droneItinerario);

            DetachLocal <DroneItinerario>(_context, d => d.Id == droneItinerario.Id);
            DetachLocal <Drone>(_context, d => d.Id == droneItinerario.Drone.Id);

            _context.DroneItinerario.Update(droneItinerario);
            await _context.SaveChangesAsync();

            return(droneItinerario);
        }
Example #6
0
        public async Task <bool> Handle(EntregarPedidoCommand message, CancellationToken cancellationToken)
        {
            if (!ValidarComando(message))
            {
                return(false);
            }

            var drone = await _droneQueries.ObterDrone(message.DroneId);

            var pedido = await _pedidoQueries.ObterPedido(message.PedidoId);

            var pedidoAlterado = new Pedido()
            {
                Peso      = pedido.Peso,
                Latitude  = pedido.Latitude,
                Longitude = pedido.Longitude,
                Id        = pedido.Id
            };
            var entrega = new Entrega()
            {
                DataPrevisao = message.DataPrevisao,
                DroneId      = message.DroneId,
                PedidoId     = message.PedidoId
            };

            var itinerario = new DroneItinerario()
            {
                DroneId     = drone.Id,
                StatusDrone = EStatusDrone.EmTransito,
                DataHora    = DateTime.Now
            };

            await _itinerarioRepository.InsertAsync(itinerario);

            await _itinerarioRepository.UnitOfWork.Commit();

            await _entregaRepository.InsertAsync(entrega);

            await _entregaRepository.UnitOfWork.Commit();

            pedidoAlterado.Entrega = entrega;
            await _pedidoRepository.UpdateAsync(pedidoAlterado);

            await _pedidoRepository.UnitOfWork.Commit();

            return(true);
        }
Example #7
0
        private async Task CriarDroneItinerario()
        {
            var dronesId = _droneRepository.ObterTodos().Result.Select(d => d.Id).ToList();

            var droneItininerarios = _droneItinerarioRepository.ObterTodos().Result.Select(i => i.DroneId).ToList();

            var dronesSemItinerario = dronesId.Except(droneItininerarios).ToList();

            foreach (var droneId in dronesSemItinerario)
            {
                DroneItinerario droneItinerario = new DroneItinerario();
                droneItinerario.InformarDataHora(DateTime.Now);
                droneItinerario.InformarStatusDrone(EnumStatusDrone.Disponivel);
                droneItinerario.InformarDrone(_droneRepository.ObterPorId(droneId).Result);
                await _droneItinerarioRepository.Adicionar(droneItinerario);
            }
        }
Example #8
0
        private async Task criarDroneItinerario()
        {
            var dronesId = _droneRepository.GetAll().Result.Select(d => d.Id).ToList();

            var droneItininerarios = _droneItinerarioRepository.GetAll().Result.Select(i => i.DroneId).ToList();

            var dronesSemItinerario = dronesId.Except(droneItininerarios).ToList();

            foreach (var droneId in dronesSemItinerario)
            {
                DroneItinerario droneItinerario = new DroneItinerario();
                //droneItinerario.Drone = _unitOfWork.Drones.GetById(droneId);
                droneItinerario.InformarDataHora(DateTime.Now);
                droneItinerario.InformarStatusDrone(EnumStatusDrone.Disponivel);
                droneItinerario.InformarDrone(_droneRepository.GetById(droneId).Result);
                await _droneItinerarioRepository.Insert(droneItinerario);
            }
        }
        public async Task <bool> Handle(CarregarBareriaDroneCommand message, CancellationToken cancellationToken)
        {
            if (!ValidarComando(message))
            {
                return(false);
            }

            var drone = await _droneRepository.GetByIdAsync(message.Id);

            if (drone == null)
            {
                var itinerario = new DroneItinerario()
                {
                    DataHora = DateTime.Now, Drone = drone, DroneId = drone.Id, StatusDrone = EStatusDrone.Carregando
                };
                await _itinerarioRepository.InsertAsync(itinerario);
            }

            return(await _droneRepository.UnitOfWork.Commit());
        }
Example #10
0
        private void criarDroneItinerario()
        {
            var dronesId = _unitOfWork.Drones.GetAll().Select(d => d.Id).ToList();

            var droneItininerarios = _unitOfWork.DroneItinerario.GetAll().Select(i => i.DroneId).ToList();

            var dronesSemItinerario = dronesId.Except(droneItininerarios).ToList();

            foreach (var droneId in dronesSemItinerario)
            {
                DroneItinerario droneItinerario = new DroneItinerario();
                droneItinerario.DataHora    = DateTime.Now;
                droneItinerario.Drone       = _unitOfWork.Drones.GetById(droneId);
                droneItinerario.DroneId     = droneId;
                droneItinerario.StatusDrone = EnumStatusDrone.Disponivel;

                _unitOfWork.DroneItinerario.Insert(droneItinerario);
            }

            _unitOfWork.Save();
        }
Example #11
0
        public async Task <bool> Handle(AdicionarDroneCommand request, CancellationToken cancellationToken)
        {
            if (!request.EhValido())
            {
                return(false);
            }

            var drone = new Drone();

            drone.Capacidade        = request.Capacidade;
            drone.Velocidade        = request.Velocidade;
            drone.Autonomia         = request.Autonomia;
            drone.Carga             = request.Carga;
            drone.AutonomiaRestante = request.AutonomiaRestante;

            await _droneRepository.Adicionar(drone);

            var resultDrone = await _droneRepository.UnitOfWork.Commit();

            if (resultDrone)
            {
                var droneItinerario = new DroneItinerario
                {
                    DataHora    = request.DataHora,
                    Drone       = drone,
                    DroneId     = drone.Id,
                    StatusDrone = request.StatusDrone
                };

                await _droneItinerarioRepository.Adicionar(droneItinerario);

                return(await _droneItinerarioRepository.UnitOfWork.Commit());
            }
            else
            {
                return(false);
            }
        }
Example #12
0
        public async Task <ActionResult <Drone> > PostDrone(DroneDTO droneDTO)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest());
            }

            if (droneDTO.Autonomia <= 0 || droneDTO.Capacidade <= 0 || droneDTO.Carga <= 0 || droneDTO.Velocidade <= 0)
            {
                return(BadRequest("Valores inválidos para Autonomia, Capacidade, Carga e/ou Velocidade."));
            }

            Drone drone = new Drone()
            {
                Velocidade        = droneDTO.Velocidade,
                Autonomia         = droneDTO.Autonomia,
                AutonomiaRestante = droneDTO.Autonomia,
                Carga             = droneDTO.Carga,
                Capacidade        = droneDTO.Capacidade
            };

            bool result = await _droneService.Insert(drone);

            if (result)
            {
                DroneItinerario droneItinerario = new DroneItinerario();
                droneItinerario.DataHora    = System.DateTime.Now;
                droneItinerario.Drone       = drone;
                droneItinerario.DroneId     = drone.Id;
                droneItinerario.StatusDrone = EnumStatusDrone.Disponivel;

                await _droneItinerarioService.Insert(droneItinerario);
            }

            return(CreatedAtAction("GetDrone", new { id = drone.Id }, drone));
        }
 public async Task <bool> Delete(DroneItinerario droneItinerario)
 {
     _context.DroneItinerario.Remove(droneItinerario);
     return(await _context.SaveChangesAsync() > 0);
 }
 public async Task Insert(DroneItinerario droneItinerario)
 {
     await Task.Run(() => _context.DroneItinerario.Add(droneItinerario));
 }
 public async Task Update(DroneItinerario droneItinerario)
 {
     await Task.Run(() => _context.DroneItinerario.Update(droneItinerario));
 }
Example #16
0
 public async Task <DroneItinerario> Update(DroneItinerario droneItinerario)
 {
     return(await _droneItinerarioRepository.Update(droneItinerario));
 }
Example #17
0
 public async Task <bool> Insert(DroneItinerario droneItinerario)
 {
     return(await _droneItinerarioRepository.Insert(droneItinerario));
 }
Example #18
0
 public async Task <bool> Delete(DroneItinerario droneItinerario)
 {
     return(await _droneItinerarioRepository.Delete(droneItinerario));
 }
Example #19
0
 public async Task Update(DroneItinerario droneItinerario)
 {
     await _droneItinerarioRepository.Update(droneItinerario);
 }
Example #20
0
 public async void Insert(DroneItinerario droneItinerario)
 {
     _context.DroneItinerario.Add(droneItinerario);
     await _context.SaveChangesAsync();
 }
Example #21
0
        private async Task distribuirPedidos()
        {
            IList <Pedido> pedidos = new List <Pedido>();

            try
            {
                // pedidos mais antigos vao primeiro
                pedidos = _repositoryPedido.GetPedidosEmAberto().Result;
            }
            catch (Exception ex)
            {
                throw ex;
            }

            if (!pedidos.Any())
            {
                return;
            }

            var droneItinerarios = _droneItinerarioRepository.GetAll().Result
                                   .Where(d => d.StatusDrone == EnumStatusDrone.Disponivel)
                                   .ToList();

            foreach (var droneItinerario in droneItinerarios)
            {
                droneItinerario.Drone = await _droneRepository.GetById(droneItinerario.DroneId);
            }

            var dronesDisponiveis = droneItinerarios.Select(d => d.Drone).OrderBy(d => d.Capacidade).ToList();

            if (!dronesDisponiveis.Any())
            {
                return;
            }

            IDictionary <Drone, IList <Pedido> > pedidosPorDrone = new Dictionary <Drone, IList <Pedido> >();
            IList <Pedido> pedidosEntregar      = new List <Pedido>();
            IList <Pedido> pedidosDistribuidos  = new List <Pedido>();
            double         distanciaTrajeto     = 0;
            double         distanciaRetorno     = 0;
            double         distanciaPercorrida  = 0;
            double         distanciaTotal       = 0;
            double         latitudeOrigem       = 0;
            double         longitudeOrigem      = 0;
            int            tempoTrajetoCompleto = 0;

            foreach (var drone in dronesDisponiveis)
            {
                pedidosEntregar.Clear();

                distanciaTrajeto     = 0;
                distanciaRetorno     = 0;
                distanciaPercorrida  = 0;
                distanciaTotal       = 0;
                latitudeOrigem       = 0;
                longitudeOrigem      = 0;
                tempoTrajetoCompleto = 0;

                int capacidadeDisponivel = drone.Capacidade;
                int autonomiaDisponivel  = drone.AutonomiaRestante;

                foreach (var pedido in pedidos)
                {
                    if (pedidosDistribuidos.Contains(pedido))
                    {
                        continue;
                    }

                    if (pedido.Peso <= capacidadeDisponivel)
                    {
                        if (pedidosEntregar.Any())
                        {
                            latitudeOrigem  = (double)pedidosEntregar.Last().Cliente.Latitude;
                            longitudeOrigem = (double)pedidosEntregar.Last().Cliente.Longitude;
                        }
                        else
                        {
                            latitudeOrigem  = _latitudeLoja;
                            longitudeOrigem = _longitudeLoja;
                        }

                        distanciaTrajeto = calcularDistanciaEmKilometros(latitudeOrigem, longitudeOrigem, (double)pedido.Cliente.Latitude, (double)pedido.Cliente.Longitude);
                        distanciaRetorno = calcularDistanciaEmKilometros((double)pedido.Cliente.Latitude, (double)pedido.Cliente.Longitude, _latitudeLoja, _longitudeLoja);

                        distanciaTotal = distanciaPercorrida + distanciaTrajeto + distanciaRetorno;

                        tempoTrajetoCompleto = calcularTempoTrajetoEmMinutos(distanciaTotal, drone.Velocidade);

                        if (tempoTrajetoCompleto <= drone.AutonomiaRestante)
                        {
                            pedidosEntregar.Add(pedido);

                            distanciaPercorrida += distanciaTrajeto;

                            capacidadeDisponivel -= pedido.Peso;
                            autonomiaDisponivel   = drone.AutonomiaRestante - tempoTrajetoCompleto;
                        }
                    }
                    else
                    {
                        continue;
                    }

                    // se não cabe mais, nao precisa verificar os demais pedidos
                    if (capacidadeDisponivel <= 0 || tempoTrajetoCompleto >= drone.AutonomiaRestante)
                    {
                        break;
                    }
                }

                if (pedidosEntregar.Any())
                {
                    drone.AutonomiaRestante = autonomiaDisponivel;

                    if (!pedidosPorDrone.ContainsKey(drone))
                    {
                        pedidosPorDrone.Add(drone, new List <Pedido>());
                    }

                    foreach (var pedido in pedidosEntregar)
                    {
                        pedidosPorDrone[drone].Add(pedido);
                    }

                    pedidosDistribuidos = pedidosDistribuidos.Concat(pedidosEntregar).ToList();
                }
            }

            if (pedidosPorDrone.Count > 0)
            {
                foreach (var item in pedidosPorDrone)
                {
                    Drone drone = item.Key;

                    DroneItinerario droneItinerario = droneItinerarios.Where(d => d.DroneId == drone.Id).FirstOrDefault();
                    droneItinerario.DataHora    = DateTime.Now;
                    droneItinerario.Drone       = drone;
                    droneItinerario.DroneId     = drone.Id;
                    droneItinerario.StatusDrone = EnumStatusDrone.EmTransito;

                    await _droneRepository.Update(drone);

                    await _droneItinerarioRepository.Update(droneItinerario);

                    foreach (var pedido in item.Value)
                    {
                        pedido.Drone  = drone;
                        pedido.Status = EnumStatusPedido.EmTransito;

                        await _repositoryPedido.Update(pedido);
                    }
                }
            }
        }
Example #22
0
        public async Task <bool> Insert(DroneItinerario droneItinerario)
        {
            await _droneItinerarioRepository.Adicionar(droneItinerario);

            return(await _droneItinerarioRepository.UnitOfWork.Commit());
        }
 public async Task DeleteAsync(DroneItinerario entity)
 {
     await Task.Run(() => _context.Remove(entity));
 }
 public async Task <bool> Insert(DroneItinerario droneItinerario)
 {
     _context.DroneItinerario.Add(droneItinerario);
     return(await _context.SaveChangesAsync() > 0);
 }
 public async Task InsertAsync(DroneItinerario entity)
 {
     await _context.AddAsync(entity);
 }
Example #26
0
 public async Task Insert(DroneItinerario droneItinerario)
 {
     await _droneItinerarioRepository.Insert(droneItinerario);
 }
Example #27
0
        public async Task <bool> Update(DroneItinerario droneItinerario)
        {
            await _droneItinerarioRepository.Atualizar(droneItinerario);

            return(await _droneItinerarioRepository.UnitOfWork.Commit());
        }
 public async Task UpdateAsync(DroneItinerario entity)
 {
     _context.Entry(entity).State = EntityState.Modified;
     await Task.Run(() => _context.Update(entity));
 }
Example #29
0
 public async void Delete(DroneItinerario droneItinerario)
 {
     _context.DroneItinerario.Remove(droneItinerario);
     await _context.SaveChangesAsync();
 }
        public async Task <ActionResult <Pedido> > PostPedido(Pedido pedido)
        {
            // existe drone com capacidade maior que o peso do pedido (limite maximo 12kg)


            var dronesDisponiveisIds = _unitOfWork.DroneItinerario.GetAll().Where(d => d.StatusDrone == EnumStatusDrone.Disponivel).Select(s => s.DroneId).ToList();

            if (!dronesDisponiveisIds.Any())
            {
                return(BadRequest("Rejeitado: Não há entregadores disponíveis."));
            }

            Drone drone = _unitOfWork.Drones.GetAll().Where(d => dronesDisponiveisIds.Contains(d.Id) && d.Capacidade >= pedido.Peso).FirstOrDefault();

            if (drone == null)
            {
                return(BadRequest("Rejeitado: Pedido acima do peso máximo aceito."));
            }

            // calcular distancia do trajeto
            // calcular tempo total (ida e volta) do trajeto (limite maximo 35m)
            // existe um drone que atende essas condicoes

            double distancia = CalcularDistanciaEmKilometros((double)pedido.Latitude, (double)pedido.Longitude);

            distancia = distancia * 2;

            // tempo = distancia / velocidade
            // 80km / 40km/h = 2h
            double tempoTrajetoCompleto = distancia / drone.Velocidade;

            tempoTrajetoCompleto = tempoTrajetoCompleto * 60;

            if (tempoTrajetoCompleto > drone.Autonomia)
            {
                return(BadRequest("Rejeitado: Fora da área de entrega."));
            }

            //todo: Tempo médio de carga de bateria de TODOS os Drone: 1 hora

            pedido.DataHora        = DateTime.Now;
            pedido.PrevisaoEntrega = DateTime.Now.AddMinutes(Convert.ToInt32(tempoTrajetoCompleto / 2));
            pedido.Drone           = drone;
            pedido.Status          = EnumStatusPedido.EmTransito;

            DroneItinerario droneItinerario = _unitOfWork.DroneItinerario.GetAll().Where(i => i.DroneId == drone.Id).FirstOrDefault();

            if (droneItinerario == null)
            {
                droneItinerario = new DroneItinerario();

                droneItinerario.DataHora    = DateTime.Now;
                droneItinerario.Drone       = drone;
                droneItinerario.StatusDrone = EnumStatusDrone.EmTransito;

                _unitOfWork.DroneItinerario.Insert(droneItinerario);
            }
            else
            {
                droneItinerario.DataHora    = DateTime.Now;
                droneItinerario.Drone       = drone;
                droneItinerario.StatusDrone = EnumStatusDrone.EmTransito;

                _unitOfWork.DroneItinerario.Update(droneItinerario);
            }

            drone.AutonomiaRestante = drone.AutonomiaRestante - Convert.ToInt32(tempoTrajetoCompleto);

            _unitOfWork.Pedidos.Insert(pedido);
            _unitOfWork.Drones.Update(drone);

            await Task.Run(
                () =>
            {
                _unitOfWork.Save();
            });

            return(CreatedAtAction("GetPedido", new { id = pedido.Id }, pedido));
        }