public async Task <ActionResult <DeliveryRoute> > PostDeliveryRoute(DeliveryRoute deliveryRoute)
{
_context.DeliveryRoute.Add(deliveryRoute);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetDeliveryRoute", new { id = deliveryRoute.Id }, deliveryRoute));
}
public async Task <IActionResult> Put(DeliveryRoute deliveryRoute)
{
_context.Entry(deliveryRoute).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <IActionResult> PutDeliveryRoute(Guid id, DeliveryRoute deliveryRoute)
{
if (id != deliveryRoute.Id)
{
return(BadRequest());
}
_context.Entry(deliveryRoute).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DeliveryRouteExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Post(DeliveryRoute deliveryRoute)
{
_context.Add(deliveryRoute);
await _context.SaveChangesAsync();
return(Ok(deliveryRoute.Id));
}
private List <DeliveryRoute> GetSelectedItem()
{
List <DeliveryRoute> Routeee = new List <DeliveryRoute>();
DeliveryRoute itm = new DeliveryRoute();
itm.strDeliveryRoute = DG.CurrentRow.Cells[0].Value.ToString();
Routeee.Add(itm);
return(Routeee);
}
public async Task <IActionResult> Delete(int id)
{
var deliveryRoute = new DeliveryRoute {
Id = id
};
_context.Remove(deliveryRoute);
await _context.SaveChangesAsync();
return(NoContent());
}
public void Clustering()
{
var routesToDelete = _context.DeliveryRoutes.ToList();
foreach (var route in routesToDelete)
{
_context.DeliveryRoutes.Remove(route);
}
_context.SaveChanges();
var packages = GetPackages();
List <Driver> driverList = new List <Driver>(GetDrivers());
int drivers = driverList.Count();
List <Package> packagesWithData = new List <Package>();
foreach (var package in packages)
{
var json =
new WebClient().DownloadString("https://maps.googleapis.com/maps/api/geocode/json?address=" +
package.Destination + "&key=AIzaSyBMVIteB6a_vtVSunhpk56yZWeTSGN2CkM");
var data = JObject.Parse(json);
package.Latitude =
(double)data["results"][0].SelectToken("geometry").SelectToken("location").SelectToken("lat");
package.Longitude =
(double)data["results"][0].SelectToken("geometry").SelectToken("location").SelectToken("lng");
packagesWithData.Add(package);
}
_context.SaveChanges();
Delivery d = new Delivery(drivers, (List <Package>)packages);
d.Packages = new LinkedList <Package>(packages);
LinkedList <PackageCluster> clusters = d.clustering();
for (int i = 0; i < clusters.Count; i++)
{
List <Package> packageList = new List <Package>(clusters.ElementAt(i).AssignedPackages);
for (int j = 0; j < packageList.Count; j++)
{
DeliveryRoute dr = new DeliveryRoute();
dr.Driver = driverList.ElementAt(i);
dr.Package = packageList.ElementAt(j);
_context.DeliveryRoutes.Add(dr);
}
}
_context.SaveChanges();
}
public IHttpActionResult BookDelivery(string apiKey, [FromBody] DeliveryRoute deliveryRoute)
{
if (!_securityService.IsAuthenticated(apiKey))
{
return(Unauthorized());
}
var delivery = Mapper.MapFromDeliveryRoute(deliveryRoute);
var isBooked = _bookingService.BookDelivery(delivery);
return(Ok(isBooked));
}
// POST: api/DeliveryRoute
public DeliveryRoute Post([FromBody] DeliveryRoute value)
{
try
{
var pathFinder = new PathFinder(value.StartPoint, value.EndPoint, value.PreferCheapestPath);
pathFinder.FindShortestPaths();
var deliveryRouteDistances = pathFinder.GetEndPointDistances();
value.RoutePath = pathFinder.GetDeliveryRoutePoints();
value.AverageTime = !value.PreferCheapestPath ? deliveryRouteDistances.Item1 : deliveryRouteDistances.Item2;
value.AverageCost = value.PreferCheapestPath ? deliveryRouteDistances.Item1 : deliveryRouteDistances.Item2;
return(value);
}
catch (Exception ex)
{
Console.WriteLine("DeliveryRoute Exception: {0}", ex);
return(null);
}
}
public void GetFastestRoute()
{
var dbBridge = new DatabaseBridge();
// Add points.
{
var pointList = new List <Point>
{
new Point("A"),
new Point("B"),
new Point("C"),
new Point("D"),
new Point("E"),
new Point("F"),
new Point("G"),
new Point("H"),
new Point("I")
};
foreach (var point in pointList)
{
dbBridge.CreatePoint(point);
}
}
// Add routes.
{
var routeList = new List <Route>
{
new Route(20, 1, 1, 3),
new Route(5, 30, 1, 5),
new Route(1, 10, 1, 8),
new Route(12, 1, 3, 2),
new Route(1, 30, 8, 5),
new Route(5, 3, 5, 4),
new Route(50, 4, 4, 6),
new Route(50, 40, 6, 7),
new Route(50, 45, 6, 9),
new Route(73, 64, 7, 2),
new Route(5, 65, 9, 2),
};
foreach (var route in routeList)
{
dbBridge.CreateRoute(route);
}
}
var deliveryRoute = new DeliveryRoute
{
PreferCheapestPath = false,
StartPoint = "A",
EndPoint = "E",
};
var pathFinder = new PathFinder(deliveryRoute.StartPoint, deliveryRoute.EndPoint, deliveryRoute.PreferCheapestPath);
pathFinder.FindShortestPaths();
var deliveryRouteDistances = pathFinder.GetEndPointDistances();
deliveryRoute.RoutePath = pathFinder.GetDeliveryRoutePoints();
deliveryRoute.AverageTime = deliveryRouteDistances.Item1;
deliveryRoute.AverageCost = deliveryRouteDistances.Item2;
bool validResult = deliveryRoute.AverageCost == 5 && deliveryRoute.AverageTime == 30;
Assert.IsTrue(validResult);
}
private void FindRoutes(string coveredRoute, ref Dictionary <string, int> visited, DeliveryRoute route, string end, int maxStop, int currentStop,
int aggregateDeliveryCost, int currentCost, int maxDeliveryCost, int maxRouteRepeat, IEnumerable <DeliveryRoute> allDeliveryRoutes)
{
aggregateDeliveryCost = UpdateAggregateDeliveryCost(aggregateDeliveryCost, currentCost);
if (CanRepeatRoute(maxRouteRepeat))
{
maxRouteRepeat = UpdateMaxRouteRepeat(maxRouteRepeat);
}
if (!string.IsNullOrWhiteSpace(coveredRoute))
{
UpdateVisited(coveredRoute, ref visited);
if (ExceedMaxRouteRepeat(coveredRoute, visited, maxRouteRepeat))
{
return;
}
}
if (ExceedMaxDeliveryCost(aggregateDeliveryCost, maxDeliveryCost))
{
return;
}
if (route.End.Equals(end, StringComparison.OrdinalIgnoreCase))
{
IncreasePossibleDeliveryRoute();
if (AbleToRepeatTheSameRoute(maxRouteRepeat))
{
return;
}
}
if (ExceedMaxStop(maxStop, currentStop))
{
return;
}
currentStop = UpdateCurrentStop(currentStop);
var deliveryRoutes = allDeliveryRoutes.Where(deliveryRoute => deliveryRoute.Start.Equals(route.End, StringComparison.OrdinalIgnoreCase));
foreach (var deliveryRoute in deliveryRoutes)
{
coveredRoute = UpdateCoveredRoute(route.End, deliveryRoute);
FindRoutes
(
coveredRoute: coveredRoute,
visited: ref visited,
route: deliveryRoute,
end: end,
maxStop: maxStop,
currentStop: currentStop,
aggregateDeliveryCost: aggregateDeliveryCost,
currentCost: deliveryRoute.Cost,
maxDeliveryCost: maxDeliveryCost,
maxRouteRepeat: maxRouteRepeat,
allDeliveryRoutes: allDeliveryRoutes
);
UnMarkVisited(coveredRoute, visited);
}
}
private string UpdateCoveredRoute(string start, DeliveryRoute deliveryRoute) => start + deliveryRoute.End;
private void FindTheCheapestDeliveryCost(string coveredRoute, ref Dictionary <string, int> visited, DeliveryRoute route, string end, int aggregateDeliveryCost, int currentCost, IEnumerable <DeliveryRoute> allDeliveryRoutes)
{
aggregateDeliveryCost = UpdateAggregateDeliveryCost(aggregateDeliveryCost, currentCost);
if (!string.IsNullOrWhiteSpace(coveredRoute))
{
UpdateVisited(coveredRoute, ref visited);
if (IsRepeated(coveredRoute, visited))
{
return;
}
}
if (route.End.Equals(end, StringComparison.OrdinalIgnoreCase))
{
UpdateTheCheapestDeliveryCost(aggregateDeliveryCost);
}
var deliveryRoutes = allDeliveryRoutes.Where(deliveryRoute => deliveryRoute.Start.Equals(route.End, StringComparison.OrdinalIgnoreCase));
foreach (var deliveryRoute in deliveryRoutes)
{
coveredRoute = UpdateCoveredRoute(route.End, deliveryRoute);
FindTheCheapestDeliveryCost
(
coveredRoute: coveredRoute,
visited: ref visited,
route: deliveryRoute,
end: end,
aggregateDeliveryCost: aggregateDeliveryCost,
currentCost: deliveryRoute.Cost,
allDeliveryRoutes: allDeliveryRoutes
);
UnMarkVisited(coveredRoute, visited);
}
}
public List <DeliveryRoute> GetCurrentOrdersRoute([FromBody] DeliveryAreas deliveryAreas)
{
var areaGroups = deliveryAreas.deliveryAreas.Select(x => x.postcodes).ToList();
var restConsumer = new RESTconsumer(configuration);
var currentOrderList = restConsumer.apiRequestOrderList("GET", "orders").Where(x => x.status == "processing").ToList();
//Sort orders by area HERE into a nested list of orders, then run this in a loop
//Create a list of orders for each List of areas, plus an additional one for any non-conforming areas
var ordersByArea = new List <List <RootOrder> >();
for (int i = 0; i <= areaGroups.Count(); i++)
{
ordersByArea.Add(new List <RootOrder>());
}
//Go through each order and check the if the postcode is in each list, if so, copy it to correct list, else put it in spare list
foreach (var order in currentOrderList)
{
bool isInArea = false;
for (int i = 0; i < areaGroups.Count(); i++)
{
if (areaGroups[i].Contains(order.shipping.postcode))
{
ordersByArea[i].Add(order);
isInArea = true;
break;
}
}
if (!isInArea)
{
ordersByArea.Last().Add(order);
}
}
//Replce this with DEPOT Adress, should probavbly be stored in config, or provided via the API call
string depotAddress = configuration.GetValue <string>("Routing:DepotAddress");
//Then loop through this list of orders, performing the route optimisation for each one.
//Will need to add the depot location (ie ellis creek farms - we should put this values somewehere nice)
//Structure to store order in
int index = 0;
var deliveryRoutes = new List <DeliveryRoute>();
foreach (var orderList in ordersByArea)
{
string name;
//Get the name of the delivery area
if (index < deliveryAreas.deliveryAreas.Count())
{
name = deliveryAreas.deliveryAreas[index].name;
}
else
{
name = "Other";
}
index++;
//If the list of orders for an area is emtpy, skip the area
if (orderList.Count == 0)
{
continue;
}
var deliveryRoute = new DeliveryRoute();
deliveryRoute.name = name;
List <string> addressList = new List <string>();
addressList.Add(depotAddress);
//Add each of the orders full address to the list
addressList.AddRange(orderList.Select(x => x.shipping.fullAddress).ToList());
//Also need to add the depot location here
string googleApiKey = configuration.GetValue <string>("GoogleAPIKey");
RouteOptimization routeOptimization = new RouteOptimization(_httpClientFactory.CreateClient(), googleApiKey);
long[,] timeWindows = new long[addressList.Count(), 2];
timeWindows[0, 0] = 0;
timeWindows[0, 1] = 999999999999; // for the depot, no time constraints
for (int i = 1; i <= orderList.Count(); i++)
{
if (orderList[i - 1].time_window is null)
{
timeWindows[i, 0] = 0;
timeWindows[i, 1] = 999999999999;
}
else
{
var startWindow = orderList[i - 1].time_window[0];
var endWindow = orderList[i - 1].time_window[1];
if (String.IsNullOrEmpty(startWindow))
{
timeWindows[i, 0] = 0;
}
else
{
timeWindows[i, 0] = (long)(TimeSpan.Parse(orderList[i - 1].time_window[0]).TotalSeconds);
}
if (String.IsNullOrEmpty(endWindow))
{
timeWindows[i, 1] = 999999999999;
}
else
{
timeWindows[i, 1] = (long)(TimeSpan.Parse(orderList[i - 1].time_window[1]).TotalSeconds);
}
}
}
List <string> optimisedRoute = routeOptimization.route(addressList, timeWindows);
var optimisedOrders = orderList.OrderBy(x => optimisedRoute.IndexOf(x.shipping.fullAddress)).ToList();
deliveryRoute.orders = optimisedOrders;
deliveryRoute.optimisedRoute = optimisedRoute;
List <int> orderNumbers = new List <int>();
orderNumbers.Add(0);
orderNumbers.AddRange(optimisedOrders.Select(x => x.id).ToList());
orderNumbers.Add(0);
deliveryRoute.orderNumbers = orderNumbers;
deliveryRoutes.Add(deliveryRoute);
}
return(deliveryRoutes);
}
public static Levarance MapFromDeliveryRoute(DeliveryRoute deliveryRoute)
{
return(new Levarance
{
});
}
