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);
}
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);
}
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);
}
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);
}
}
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());
}
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();
}
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);
}
}
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));
}
public async Task <DroneItinerario> Update(DroneItinerario droneItinerario)
{
return(await _droneItinerarioRepository.Update(droneItinerario));
}
public async Task <bool> Insert(DroneItinerario droneItinerario)
{
return(await _droneItinerarioRepository.Insert(droneItinerario));
}
public async Task <bool> Delete(DroneItinerario droneItinerario)
{
return(await _droneItinerarioRepository.Delete(droneItinerario));
}
public async Task Update(DroneItinerario droneItinerario)
{
await _droneItinerarioRepository.Update(droneItinerario);
}
public async void Insert(DroneItinerario droneItinerario)
{
_context.DroneItinerario.Add(droneItinerario);
await _context.SaveChangesAsync();
}
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);
}
}
}
}
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);
}
public async Task Insert(DroneItinerario droneItinerario)
{
await _droneItinerarioRepository.Insert(droneItinerario);
}
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));
}
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));
}