private void RouteProvider_RoutingCompleted(object sender, RoutingCompletedEventArgs e)
{
this.findRouteButton.IsEnabled = true;
RouteResponse routeResponse = e.Response as RouteResponse;
if (routeResponse != null &&
routeResponse.Error == null)
{
if (routeResponse.Result != null &&
routeResponse.Result.RoutePath != null)
{
PolylineData routeLine = new PolylineData()
{
Points = routeResponse.Result.RoutePath.Points,
ShapeFill = new MapShapeFill()
{
Stroke = new SolidColorBrush(Colors.Red),
StrokeThickness = 2
}
};
this.routeLayer.Items.Add(routeLine);
}
}
}
private void CreateTripRoute(Wycieczka newTrip, RouteResponse route)
{
var tripRoute = new Odcinek()
{
WycieczkaId = newTrip.Id
};
if (route.IsCustomRoute())
{
var start = route.Start.ToModel();
var end = route.End.ToModel();
var mountainGroup = _context.GrupaGorska.FirstOrDefault(m => m.Nazwa == route.MountainGroup);
_context.Update(start);
_context.Update(end);
_context.SaveChanges();
OdcinekWłasny customRoute = new OdcinekWłasny()
{
Punkty = route.Points,
PoczatekId = start.Id,
KoniecId = end.Id,
GrupaGorska = mountainGroup
};
_context.OdcinekWłasny.Add(customRoute);
_context.SaveChanges();
tripRoute.OdcinekWłasnyId = customRoute.Id;
}
else
{
tripRoute.OdcinekPunktowanyId = route.Id;
}
newTrip.Odcinek.Add(tripRoute);
}
private RouteResponse TryRequestRouteResponse()
{
Osrm5x osrm = new Osrm5x(OsrmServerBaseUrl);
RouteResponse response = null;
try
{
RouteRequest request = new RouteRequest()
{
Coordinates = OsrmConverter.ConvertGeocoordinatesToLocations(Coordinates).ToArray(),
Steps = true,
Alternative = CalculateAlternativeRoutes
};
response = osrm.Route(request);
}
catch (Exception e)
{
Console.WriteLine(e);
if (response != null)
{
Console.WriteLine("Status Code of RouteRequest: " + response.Code);
}
}
return(response);
}
/// <summary>
/// Draws the walkable route to the spear, if the spear is unavailable
/// </summary>
public async void DrawWalkableRouteToSpear(Location playerLocation, Location spearLocation)
{
if (DirManager == null)
{
DirManager = Map.DirectionsManager;
}
DirManager.Waypoints.Clear();
DirManager.Waypoints.Add(new Waypoint(playerLocation));
DirManager.Waypoints.Add(new Waypoint(spearLocation));
DirManager.RequestOptions.RouteMode = RouteModeOption.Walking;
DirManager.RequestOptions.Optimize = OptimizeOption.Walking;
//Do something with the distance
RouteResponse response = await DirManager.CalculateDirectionsAsync();
// not sure if merge conflict or not
DirManager.RenderOptions.WaypointPushpinOptions.Visible = false;
SpearHandler.Score.Distance = response.Routes[0].TravelDistance * 1000;
SpearHandler.PropertyChanged(); //Manual f*** you to binding.
if (response.HasError)
{
await SatanController.ShowMessageAsync("Route error", "The route could not be calculated.");
}
DirManager.ShowRoutePath(DirManager.ActiveRoute);
}
public async Task <RouteResponse> PatchRouteByIdentiferAsync(RouteIdentifier identifier, IDictionary <string, object> values)
{
// We'll get the intersection of known valid property names, to the incoming property
// names, as this will get us a list of only valid incoming property keys.
var userId = User.GetUserId();
var route = await _routeRepository.GetRouteByIdentifierAsync(identifier, userId);
var validProperties = new List <string> {
"owner", "uri", "title", "type", "code", "isOnline"
};
// Allow the IsDefault property to be set if the user is an admin.
if (User.IsAdmin())
{
validProperties.Add("isDefault");
}
var selectedProperties = values.Keys.Intersect(validProperties);
// Only set allowed properties using reflection and type coersion. We proper-case the
// name because our serializer automatically camel-cases json property names.
foreach (var property in selectedProperties)
{
route.SetProperty(property.ToProperCase(), values[property]);
}
// Update server properties.
route.IsCurrent = false;
route = await _routeRepository.UpdateRouteAsync(route, userId);
return(RouteResponse.Map(route));
}
public async Task <IHttpActionResult> PostPublishAsync(RouteIdentifier identifier)
{
// Load route to get source code.
var route = await _routeRepository.GetRouteByIdentifierAsync(identifier);
var code = route.Code;
// Compile code and get assembly as byte array.
var compilationResult = _compilationService.Compile(code);
// We'll save the assembly and mark the route as published if the compilation was successful.
if (compilationResult.Success)
{
route.Assembly = compilationResult.Assembly;
route.IsCurrent = true;
route.IsOnline = true;
route.PublishedOn = DateTimeOffset.UtcNow;
route = await _routeRepository.UpdateRouteAsync(route);
}
var result = new PublishResponse
{
Compilation = compilationResult,
Route = RouteResponse.Map(route)
};
// Return an error response if compile was unsuccessful, otherwise the response was successful.
return(Content(compilationResult.Success ? HttpStatusCode.OK : HttpStatusCode.InternalServerError, result));
}
public async Task <RouteResponse> GetRouteByIdentiferAsync(RouteIdentifier identifier)
{
var userId = User.GetUserId();
var route = await _routeRepository.GetRouteByIdentifierAsync(identifier, userId);
return(RouteResponse.Map(route));
}
public void GenerateUsefulRouteResponse_MultipleRoutes_AllRoutesConvertedCorrectly()
{
// Arrange
RouteResponse OldRouteFormat = new RouteResponse {
Routes = new List <Route> {
GetRoute1(), GetRoute2()
}
};
// Act
List <UsefulRouteResponse> actualResult = RoutingController.GenerateUsefulRouteResponse(OldRouteFormat);
// Assert
Assert.Equal(2, actualResult.Count);
for (int focusedResponseIndex = 0; focusedResponseIndex < Route1And2ExpectedOutcome.Count; focusedResponseIndex++)
{
Assert.Equal(Route1And2ExpectedOutcome[focusedResponseIndex].TravelTimeInSeconds, actualResult[focusedResponseIndex].TravelTimeInSeconds);
Assert.Equal(Route1And2ExpectedOutcome[focusedResponseIndex].Distance, actualResult[focusedResponseIndex].Distance);
for (int focusedPointIndex = 0; focusedPointIndex < actualResult[0].Points.Count; focusedPointIndex++)
{
Assert.Equal(Route1And2ExpectedOutcome[focusedResponseIndex].Points[focusedPointIndex].Latitude, actualResult[focusedResponseIndex].Points[focusedPointIndex].Latitude);
Assert.Equal(Route1And2ExpectedOutcome[focusedResponseIndex].Points[focusedPointIndex].Longitude, actualResult[focusedResponseIndex].Points[focusedPointIndex].Longitude);
}
}
}
public RouteResponse CC(ControlCommand command)
{
//serialize message
string serialized = JsonConvert.SerializeObject(command, new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.All
});
JObject asJO = JObject.Parse(serialized);
//create peristed message
BusMessage msg = new BusMessage()
{
PayLoad = serialized, MessageType = asJO["$type"].ToString()
};
RouteResponse toReturn = new RouteResponse()
{
Status = false
};
try {
toReturn = Bus.ReceiveMessage(msg);
} catch {
throw;
}
return(toReturn);
}
public List <MyWaypoint> CreateRoute(MyWaypoint startPoint, MyWaypoint endPoint)
{
// create route from waypointString
RouteRequest routeRequest = new RouteRequest();
// Set the credentials using a valid Bing Maps key
routeRequest.Credentials = new BingRouteService.Credentials();
routeRequest.Credentials.ApplicationId = m_bingMapKey;
// tell them that we want points along the route
routeRequest.Options = new RouteOptions();
routeRequest.Options.RoutePathType = RoutePathType.Points;
//Parse user data to create array of waypoints
BingRouteService.Waypoint[] waypoints = new BingRouteService.Waypoint[2];
BingRouteService.Waypoint point1 = new BingRouteService.Waypoint();
BingRouteService.Location location1 = new BingRouteService.Location();
location1.Latitude = startPoint.Latitude;
location1.Longitude = startPoint.Longitude;
point1.Location = location1;
point1.Description = "Start";
waypoints[0] = point1;
BingRouteService.Waypoint point2 = new BingRouteService.Waypoint();
BingRouteService.Location location2 = new BingRouteService.Location();
location2.Latitude = endPoint.Latitude;
location2.Longitude = endPoint.Longitude;
point2.Location = location2;
point2.Description = "End";
waypoints[1] = point2;
routeRequest.Waypoints = waypoints;
// Make the calculate route request
RouteServiceClient routeService = new RouteServiceClient("BasicHttpBinding_IRouteService");
RouteResponse routeResponse = routeService.CalculateRoute(routeRequest);
// pull out the lat/lon values
List <MyWaypoint> returnPoints = new List <MyWaypoint>();
if (routeResponse.Result.Legs.Length > 0)
{
//MessageBox.Show("Distance: " + routeResponse.Result.Summary.Distance.ToString()
// + " Time: " + routeResponse.Result.Summary.TimeInSeconds.ToString());
foreach (BingRouteService.Location thisPt in routeResponse.Result.RoutePath.Points)
{
MyWaypoint thisPoint = new MyWaypoint();
thisPoint.Latitude = thisPt.Latitude;
thisPoint.Longitude = thisPt.Longitude;
//thisPoint.Altitude = GetAltitude(thisPoint.Latitude, thisPoint.Longitude);
thisPoint.Altitude = 0.0;
returnPoints.Add(thisPoint);
}
}
return(returnPoints);
}
private static void InitializeRouter()
{
router = new Router();
router.AddRoute <LoadStore>("GET", "/load", Load, false);
router.AddRoute <SaveStore>("POST", "/Save", Save, false);
router.AddRoute <AuditLog>("POST", "/SaveLogEntry", SaveLogEntry, false);
router.AddRoute("GET", "/", () => RouteResponse.Page("Hello World", "text/html"), false);
}
private static IRouteResponse BeginTransaction(RequestCommon req)
{
var conn = OpenConnection();
var transaction = conn.BeginTransaction();
transactions[req.UserId] = new Transaction(transaction, conn);
return(RouteResponse.OK());
}
private static IRouteResponse SaveLogEntry(AuditLog entry)
{
using (var conn = OpenConnection())
{
CreateLogEntry(conn, entry);
}
return(RouteResponse.OK());
}
public static Models.Route MapToRoute(this RouteResponse response)
{
return(new Models.Route
{
TravelTime = response.Routes.First().Duration,
Distance = response.Routes.First().Distance,
GeoJson = response.Routes.First().Geometry.Coordinates.Select(x => new Coordinates(x[0], x[1])).ToList()
});
}
public void queRouteRequest(RouteResponse response)
{
if (!responseQueue.Contains(response))
{
//if (response.route == null)
//System.Diagnostics.Debug.WriteLine("wtf is happening right now?");
response.rdy = false;
lock (lck) responseQueue.Add(response);
}
}
public void TryExecuteRequest()
{
RouteResponse response = TryRequestRouteResponse();
if (response != null && response.Code == AcceptingStatusCode)
{
RequestSuccessful = true;
RequestedResponse = OsrmConverter.ConvertRouteResponseToRouteInfoResponse(response);
}
}
/// <summary>
/// Checks if destenation is reached
/// </summary>
/// <param name="routeResponse">graphhopper route object</param>
/// <returns>true if destenation is reached, false otherwise</returns>
private bool DestenationReached(RouteResponse routeResponse)
{
if (routeResponse != null)
{
return((routeResponse.Paths.Count > 0 && routeResponse.Paths[0].Instructions.Count == 0) ||
(routeResponse.Paths[0].Instructions.Count > 0 && routeResponse.Paths[0].Instructions[0].Sign == 4) ||
routeResponse.Paths[0].Distance < 2);
}
return(false);
}
private static IRouteResponse ImportEntity(EntityData entity)
{
IRouteResponse resp = RouteResponse.OK();
// Evil!
// Lock the whole process in case another async call fails and the client calls abort which gets
// processed and then more import calls are received.
lock (schemaLocker)
{
// We assume there's data!
using (var tconn = OpenConnection())
{
CheckForTable(tconn, entity.StoreName);
// Somewhat annoyingly we actually have to check all the records for any new field.
entity.StoreData.ForEach(d =>
{
foreach (var prop in d.Properties())
{
CheckForField(tconn, entity.StoreName, prop.Name);
}
});
}
}
var tinfo = transactions[entity.UserId];
var transaction = tinfo.t;
var conn = tinfo.c;
try
{
Interlocked.Increment(ref tinfo.transactionCount);
Console.WriteLine($"{tinfo.transactionCount} {tinfo.rollbackCount} {tinfo.c.State}");
for (int n = 0; n < entity.StoreData.Count && Interlocked.Read(ref tinfo.rollbackCount) == 0; ++n)
{
lock (schemaLocker)
{
InsertRecord(conn, transaction, entity.UserId, entity.StoreName, entity.StoreData[n]);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
resp = RouteResponse.ServerError(new { Error = ex.Message });
}
finally
{
Interlocked.Decrement(ref tinfo.transactionCount);
}
return(resp);
}
public bool CreateCustomRoute(CustomRouteRequest route, out IList <RouteResponse> result)
{
var routes = _context.GradedRoutesWithIncludedRelatedData();
var places = FindPlacesFromRoutes(routes);
PlaceResponse start = route.Start;
PlaceResponse end = route.End;
double distanceFromStart = FindClosestPlace(start, places, out Miejsce closestToStart);
double distanceFromEnd = FindClosestPlace(end, places, out Miejsce closestToEnd);
if (distanceFromStart <= MAXIMUM_DISTANCE && distanceFromEnd <= MAXIMUM_DISTANCE)
{
var mountainGroup = FindMountainGroup(closestToStart);
var mountainGroupName = _context.GrupaGorska.First(m => m.Id == mountainGroup).Nazwa;
routes = routes.Where(r => r.GrupaGorskaId == mountainGroup).ToList();
places = FindPlacesFromRoutes(routes);
//create graph from locations in a mountain group
var graph = new BidirectionalGraph <PlaceVertex, Edge <PlaceVertex> >();
var edgeCostDictionary = new Dictionary <Edge <PlaceVertex>, int>();
PopulateGraph(graph, edgeCostDictionary, places, routes);
//find path between start location and end location using A* Algorithm
AStarShortestPathAlgorithm <PlaceVertex, Edge <PlaceVertex> > astar = new AStarShortestPathAlgorithm <PlaceVertex, Edge <PlaceVertex> >(graph, x => edgeCostDictionary[x], x => 0);
var startVertex = new PlaceVertex(closestToStart.Id);
var endVertex = new PlaceVertex(closestToEnd.Id);
if (astar.ComputeDistanceBetween(startVertex, endVertex, out var path))
{
result = new List <RouteResponse>();
if (distanceFromStart >= MINIMUM_DISTANCE)
{
result.Add(RouteResponse.CreateCustomRoute(start, PlaceResponse.BuildFromModel(closestToStart), mountainGroupName, distanceFromStart));
}
result = result.Concat(CreateResponseListFromPath(path)).ToList();
if (distanceFromEnd >= MINIMUM_DISTANCE)
{
result.Add(RouteResponse.CreateCustomRoute(PlaceResponse.BuildFromModel(closestToEnd), end, mountainGroupName, distanceFromEnd));
}
return(true);
}
else
{
result = new List <RouteResponse>();
return(false);
}
}
else
{
result = new List <RouteResponse>();
return(false);
}
}
public override async Task <RouteResponse> PlanRoute(RouteRequest request, ServerCallContext context)
{
var response = new RouteResponse();
response.Miles = new Random().Next(15, 200);
response.Steps.Add("Go the traffic light");
response.Steps.Add("Turn Left");
response.Steps.Add("You have arrived");
response.DrivingTime = Timestamp.FromDateTime(DateTime.Now.AddMinutes(response.Miles).ToUniversalTime());
return(response);
}
private static string ExtractFullDescriptionFromRoute(RouteResponse routeResponse)
{
string description = routeResponse.Paths[0].Instructions[0].Text;
description += $" for : {routeResponse.Paths[0].Instructions[0].Time / 1000}[sec]";
if (routeResponse.Paths[0].Instructions.Count > 1)
{
description += $",\nand then {routeResponse.Paths[0].Instructions[1].Text}";
}
return(description);
}
private void UpdateCurrentTimeDuration(RouteResponse routeResponse)
{
if (routeResponse.Paths.Count > 0 && routeResponse.Paths[0].Instructions.Count > 0 && routeResponse.Paths[0].Instructions[0].Time != null)
{
currentTimeDuration = (int)routeResponse.Paths[0].Instructions[0].Time;
}
else
{
currentTimeDuration = NAVIGATION_MAX_SAMPLING_MILLIS;
}
}
private IList <RouteResponse> CreateResponseListFromPath(IEnumerable <IEdge <PlaceVertex> > path)
{
List <OdcinekPunktowany> routes = _context.GradedRoutesWithIncludedRelatedData().ToList();
List <RouteResponse> responses = new List <RouteResponse>();
foreach (var edge in path)
{
var route = routes.First(r => r.Id == edge.Source.RouteId);
responses.Add(RouteResponse.BuildFromModel(route));
}
return(responses);
}
private static IRouteResponse Load(LoadStore store)
{
Console.WriteLine($"Load store {store.StoreName} for user {store.UserId}");
using (var conn = OpenConnection())
{
CheckForTable(conn, store.StoreName);
var data = LoadStore(conn, store.StoreName, store.UserId);
return(RouteResponse.OK(data));
}
}
public ActionResult Route(RouteRequest routeRequest)
{
RouteResponse routeResponse = new RouteResponse();
try
{
}
catch (Exception ex) {
return(BadRequest());
}
return(Ok(routeResponse));
}
private static IRouteResponse CommitTransaction(RequestCommon req)
{
Console.WriteLine("Committing transactions...");
var tinfo = transactions[req.UserId];
Console.WriteLine($"{tinfo.transactionCount} {tinfo.rollbackCount} {tinfo.c.State}");
tinfo.t.Commit();
tinfo.c.Close();
transactions.Remove(req.UserId, out _);
return(RouteResponse.OK());
}
public async Task <RouteResponse> PostCreateRouteAsync(RouteRequest routeRequest)
{
// We'll use the patch method to set the properties values from the request to a new internal Route class.
var userId = User.GetUserId();
var route = new Route();
routeRequest.Patch(route);
route = await _routeRepository.CreateRouteAsync(route, userId);
return(RouteResponse.Map(route));
}
public override Task <RouteResponse> PlanRoute(RouteRequest request, ServerCallContext context)
{
var response = new RouteResponse();
response.Miles = new Random().Next(15, 200);
response.Steps.Add("At the end of your driveway, go left");
response.Steps.Add("Turn right at Darrow");
response.Steps.Add("Keep going until you get to the pacific");
response.Steps.Add("You missed it - " + request.Street);
response.ArrivalTime = Timestamp.FromDateTime(DateTime.Now.AddHours(12).ToUniversalTime());
return(Task.FromResult(response));
}
private static void InitializeRouter()
{
router = new Router();
router.AddRoute <RequestCommon>("GET", "/Load", Load, false);
router.AddRoute <RequestCommon>("POST", "/BeginTransaction", BeginTransaction, false);
router.AddRoute <RequestCommon>("POST", "/CommitTransaction", CommitTransaction, false);
router.AddRoute <RequestCommon>("POST", "/RollbackTransaction", RollbackTransaction, false);
router.AddRoute <AuditLogEntries>("POST", "/ImportChanges", ImportAuditLog, false);
router.AddRoute <EntityData>("POST", "/ImportEntity", ImportEntity, false);
router.AddRoute <AuditLog>("POST", "/SaveLogEntry", SaveLogEntry, false);
router.AddRoute("GET", "/", () => RouteResponse.Page("Hello World", "text/html"), false);
}
private async Task StartRouteSpeech(RouteResponse routeResponse)
{
await textToSpeechService.SpeakAsync("We're ready, let's go!");
await Task.Delay(2000);
string description = ExtractFullDescriptionFromRoute(routeResponse);
if (!string.IsNullOrEmpty(description))
{
textToSpeechService.Speak(description);
}
}
/// <summary>
/// Calculates a route based on the distance between points.
/// </summary>
/// <param name="request">The request to calculate a route for..</param>
/// <returns>A response with the calculated distance.</returns>
/// <seealso cref="IRouteService.CalculateRouteAsync"/>
public Task<RouteResponse> CalculateRouteAsync(RouteRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
const double secondsPerUnitDistance = 60 * 60;
Location start = request.Waypoints[0].Location;
Location end = request.Waypoints[0].Location;
double northSouth = start.Latitude - end.Latitude;
double eastWest = start.Longitude - end.Longitude;
double approximateDistance = Math.Sqrt(Math.Pow(northSouth, 2) + Math.Pow(eastWest, 2));
int travelTimeSeconds = (int)(approximateDistance * secondsPerUnitDistance);
RouteResponse response = new RouteResponse
{
ResponseSummary = new ResponseSummary
{
StatusCode = ResponseStatusCode.Success,
},
Result = new RouteResult
{
Summary = new RouteSummary
{
TimeInSeconds = travelTimeSeconds,
},
},
};
return TaskExt.WrapInTask(() => response);
}