public DirectionsResultView(MapWidget mapWidget, FindCloseFacilityResultView fcfResultView, RouteResult routeResult, FindClosestResourceToolbar fcrToolbar)
{
InitializeComponent();
base.DataContext = this;
// Store a reference to the MapWidget that the toolbar has been installed to.
_mapWidget = mapWidget;
_closestFaculityResult = fcfResultView;
_findClosestFacilityToolbar = fcrToolbar;
RouteName = routeResult.Directions.RouteName;
Summary = string.Format("{0:F1} {1}, {2}", routeResult.Directions.TotalLength, "miles", FormatTime(routeResult.Directions.TotalTime));
List<Graphic> features = new List<Graphic>(routeResult.Directions.Features);
features.RemoveAt(0);
List<ManeuverViewModel> directionElements = new List<ManeuverViewModel>();
Graphic previous = null;
int i = 1;
foreach (var next in features)
{
ManeuverViewModel maneuver = new ManeuverViewModel(previous, next, i++);
maneuver.Graphic.MouseLeftButtonDown += Graphic_MouseLeftButtonDown;
directionElements.Add(maneuver);
previous = next;
}
Maneuvers = directionElements;
}
public void Endless()
{
RouteResult routeResult = WebAppConfig.Router.Resolve("endless/x1/x2/x3");
Assert.AreEqual(routeResult.Controller, "Endless");
Assert.AreEqual(routeResult.Parameters["therest"], "x1/x2/x3");
}
public void ValidationDecidedRouting1()
{
WebAppConfig.Router.ClearRoutingTable();
WebAppConfig.Router.AddRoute("{controller}/{action}/{id}", "BadController", "{action}", new RegexRouteValidator("id", "xxx", RouteValidationAction.Error, RouteValidationAction.Skip));
WebAppConfig.Router.AddRoute("{controller}/{action}/{id}", "NumericController", "{action}", new RegexRouteValidator("id", "\\d+"));
WebAppConfig.Router.AddRoute("{controller}/{action}/{id}", "AlphaController", "{action}", new RegexRouteValidator("id", "[a-z]+"));
WebAppConfig.Router.AddRoute("{controller}/{action}/{id}", "MixedController", "{action}", new RegexRouteValidator("id", "[a-z].*"));
RouteResult routeResult = WebAppConfig.Router.Resolve("con/act/75");
Assert.AreEqual("NumericController", routeResult.Controller);
Assert.AreEqual(routeResult.Action, "act");
Assert.AreEqual(routeResult.Parameters["id"], "75");
routeResult = WebAppConfig.Router.Resolve("con/act/x75");
Assert.AreEqual("MixedController", routeResult.Controller);
Assert.AreEqual(routeResult.Action, "act");
Assert.AreEqual(routeResult.Parameters["id"], "x75");
routeResult = WebAppConfig.Router.Resolve("con/act/xyz");
Assert.AreEqual("AlphaController", routeResult.Controller);
Assert.AreEqual(routeResult.Action, "act");
Assert.AreEqual(routeResult.Parameters["id"], "xyz");
routeResult = WebAppConfig.Router.Resolve("con/act/75x");
Assert.IsNull(routeResult);
routeResult = WebAppConfig.Router.Resolve("con/act/xxx");
Assert.IsNull(routeResult);
}
public RouteContext Decorate(RouteContext routeContext, ShardingConnectorMetaData metaData, ShardingRule shardingRule,
ConfigurationProperties properties)
{
var sqlStatementContext = routeContext.GetSqlCommandContext();
// var tableNames = sqlStatementContext.GetTablesContext().GetTableNames();
// if (!shardingRule.TableRules.Any(o => tableNames.Any(t => o.LogicTable.EqualsIgnoreCase(t))))
// {
// return routeContext;
// }
var parameters = routeContext.GetParameterContext();
ShardingCommandValidatorFactory.NewInstance(
sqlStatementContext.GetSqlCommand())
.IfPresent(validator => validator.Validate(shardingRule, sqlStatementContext.GetSqlCommand(), parameters));
ShardingConditions shardingConditions = GetShardingConditions(parameters, sqlStatementContext, metaData.Schema, shardingRule);
var needMergeShardingValues = IsNeedMergeShardingValues(sqlStatementContext, shardingRule);
if (needMergeShardingValues && sqlStatementContext.GetSqlCommand() is DMLCommand)
{
CheckSubQueryShardingValues(sqlStatementContext, shardingRule, shardingConditions);
MergeShardingConditions(shardingConditions);
}
var shardingRouteEngine = ShardingRouteEngineFactory.NewInstance(shardingRule, metaData, sqlStatementContext, shardingConditions, properties);
RouteResult routeResult = shardingRouteEngine.Route(shardingRule);
if (needMergeShardingValues)
{
ShardingAssert.Else(1 == routeResult.GetRouteUnits().Count, "Must have one sharding with sub query.");
}
return(new RouteContext(sqlStatementContext, parameters, routeResult));
}
public static bool Route()
{
string absolutePath = HttpContext.Current.Request.Url.AbsolutePath;
if (IsNeedProcess(absolutePath) == false)
{
return(false);
}
UrlScheme scheme = GetCurrentUrlScheme();
RouteResult routeResult = s_RouteTable.Route(scheme);
if (routeResult.Succeed)
{
string path2 = TemplateManager.ParseTemplate(routeResult.OriginalPath);
HttpContext.Current.RewritePath(path2);
return(true);
}
else
{
if (AllSettings.Current.FriendlyUrlSettings.UrlFormat == UrlFormat.Query)
{
if (IsRequestBySafeUrlRewrite())
{
HttpContext.Current.Response.Redirect("~/");
}
}
}
return(false);
}
private async void SolveRouteClick(object sender, EventArgs e)
{
// Create a new route task using the San Diego route service URI
RouteTask solveRouteTask = await RouteTask.CreateAsync(_sanDiegoRouteServiceUri);
// Get the default parameters from the route task (defined with the service)
RouteParameters routeParams = await solveRouteTask.CreateDefaultParametersAsync();
// Make some changes to the default parameters
routeParams.ReturnStops = true;
routeParams.ReturnDirections = true;
// Set the list of route stops that were defined at startup
routeParams.SetStops(_routeStops);
// Solve for the best route between the stops and store the result
RouteResult solveRouteResult = await solveRouteTask.SolveRouteAsync(routeParams);
// Get the first (should be only) route from the result
Route firstRoute = solveRouteResult.Routes.First();
// Get the route geometry (polyline)
Polyline routePolyline = firstRoute.RouteGeometry;
// Create a thick purple line symbol for the route
SimpleLineSymbol routeSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Colors.Purple, 8.0);
// Create a new graphic for the route geometry and add it to the graphics overlay
Graphic routeGraphic = new Graphic(routePolyline, routeSymbol);
_routeGraphicsOverlay.Graphics.Add(routeGraphic);
// Get a list of directions for the route and display it in the list box
DirectionsListBox.ItemsSource = firstRoute.DirectionManeuvers.Select(direction => direction.DirectionText);
}
private async void CalculateAndShowRoute()
{
try
{
// Calculate the route.
RouteResult calculatedRoute = await _routeTask.SolveRouteAsync(_routeParameters);
// Get the first returned result.
Route firstResult = calculatedRoute.Routes.First();
// Get the route geometry - this is the line that shows the route.
Polyline calculatedRouteGeometry = firstResult.RouteGeometry;
// Create the route graphic from the geometry and the symbol.
Graphic routeGraphic = new Graphic(calculatedRouteGeometry, _routeSymbol);
// Clear any existing routes, then add this one to the map.
_routeOverlay.Graphics.Clear();
_routeOverlay.Graphics.Add(routeGraphic);
// Add the directions to the textbox.
PrepareDirectionsList(firstResult.DirectionManeuvers);
}
catch (Exception e)
{
System.Diagnostics.Debug.Write(e);
ShowMessage("Routing error", $"Couldn't calculate route. See debug output for details. Message: {e.Message}");
}
}
public void SetsTheValueOfTheExceptionProperty()
{
var exception = new Exception();
var routeResult = new RouteResult(exception);
Assert.That(routeResult.Exception, Is.SameAs(exception));
}
public void SetsTheValueOfTheResultProperty()
{
var result = new object();
var routeResult = new RouteResult(new TestMessage(), result);
Assert.That(routeResult.Result, Is.SameAs(result));
}
public void SetsTheValueOfTheMessageProperty()
{
var message = new TestMessage();
var routeResult = new RouteResult(message, null);
Assert.That(routeResult.Message, Is.SameAs(message));
}
public void RouteMappedId()
{
RouteResult routeResult = WebAppConfig.Router.Resolve("con/act/mappedid/99");
Assert.AreEqual(routeResult.Controller, "con");
Assert.AreEqual(routeResult.Action, "act");
Assert.AreEqual(routeResult.Parameters["id"], "99");
}
public void RouteAnyId()
{
RouteResult routeResult = WebAppConfig.Router.Resolve("con/act/anyid/500");
Assert.AreEqual(routeResult.Controller, "con");
Assert.AreEqual(routeResult.Action, "act");
Assert.AreEqual(routeResult.Parameters["id"], "500");
}
public void DefaultRoute2()
{
RouteResult routeResult = WebAppConfig.Router.Resolve("con/act");
Assert.AreEqual(routeResult.Controller, "con");
Assert.AreEqual(routeResult.Action, "act");
Assert.AreEqual(0, routeResult.Parameters.Count);
}
public void SetsTheValueOfTheMessageProperty()
{
var message = new TestMessage();
var routeResult = new RouteResult(message, null);
Assert.That(routeResult.Message, Is.SameAs(message));
}
public void SetsTheValueOfTheResultProperty()
{
var result = new object();
var routeResult = new RouteResult(new TestMessage(), result);
Assert.That(routeResult.Result, Is.SameAs(result));
}
public void SetsTheValueOfTheExceptionProperty()
{
var exception = new Exception();
var routeResult = new RouteResult(exception);
Assert.That(routeResult.Exception, Is.SameAs(exception));
}
public async Task TestOffset()
{
var store = new Mock <ICheckpointStore>();
store.Setup(s => s.GetCheckpointDataAsync("dispatcher.1", It.IsAny <CancellationToken>())).ReturnsAsync(new CheckpointData(21));
store.Setup(s => s.GetCheckpointDataAsync("dispatcher.1.endpoint1", It.IsAny <CancellationToken>())).ReturnsAsync(new CheckpointData(23));
store.Setup(s => s.GetCheckpointDataAsync("dispatcher.1.endpoint2", It.IsAny <CancellationToken>())).ReturnsAsync(new CheckpointData(22));
var endpoint1 = new TestEndpoint("endpoint1");
var endpoint2 = new TestEndpoint("endpoint2");
var endpoints = new Dictionary <Endpoint, IList <uint> > {
{ endpoint1, new List <uint>()
{
0
} }, { endpoint2, new List <uint>()
{
0
} }
};
Dispatcher dispatcher1 = await Dispatcher.CreateAsync("dispatcher.1", "hub", endpoints, SyncExecutorFactory, store.Object);
Assert.Equal(Option.Some(21L), dispatcher1.Offset);
RouteResult result1 = new RouteResult(endpoint1, 0, 3600);
RouteResult result2 = new RouteResult(endpoint2, 0, 3600);
await dispatcher1.DispatchAsync(MessageWithOffset(24L), new HashSet <RouteResult> {
result1
});
Assert.Equal(Option.Some(24L), dispatcher1.Offset);
store.Verify(s => s.SetCheckpointDataAsync("dispatcher.1", It.Is <CheckpointData>(c => c.Offset == 24), It.IsAny <CancellationToken>()), Times.Once());
store.Verify(s => s.SetCheckpointDataAsync("dispatcher.1.endpoint1", It.Is <CheckpointData>(c => c.Offset == 24), It.IsAny <CancellationToken>()), Times.Once());
await dispatcher1.DispatchAsync(MessageWithOffset(25L), new HashSet <RouteResult> {
result1, result2
});
Assert.Equal(Option.Some(25L), dispatcher1.Offset);
store.Verify(s => s.SetCheckpointDataAsync("dispatcher.1", It.Is <CheckpointData>(c => c.Offset == 25), It.IsAny <CancellationToken>()), Times.Once());
store.Verify(s => s.SetCheckpointDataAsync("dispatcher.1.endpoint1", It.Is <CheckpointData>(c => c.Offset == 25), It.IsAny <CancellationToken>()), Times.Once());
store.Verify(s => s.SetCheckpointDataAsync("dispatcher.1.endpoint2", It.Is <CheckpointData>(c => c.Offset == 25), It.IsAny <CancellationToken>()), Times.Once());
await dispatcher1.DispatchAsync(MessageWithOffset(26L), new HashSet <RouteResult> {
result2
});
Assert.Equal(Option.Some(26L), dispatcher1.Offset);
store.Verify(s => s.SetCheckpointDataAsync("dispatcher.1", It.Is <CheckpointData>(c => c.Offset == 26), It.IsAny <CancellationToken>()), Times.Once());
store.Verify(s => s.SetCheckpointDataAsync("dispatcher.1.endpoint2", It.Is <CheckpointData>(c => c.Offset == 26), It.IsAny <CancellationToken>()), Times.Once());
await dispatcher1.CloseAsync(CancellationToken.None);
Dispatcher dispatcher2 = await Dispatcher.CreateAsync("dispatcher.2", "hub", new Dictionary <Endpoint, IList <uint> >(), SyncExecutorFactory);
Assert.Equal(Option.None <long>(), dispatcher2.Offset);
await dispatcher2.CloseAsync(CancellationToken.None);
}
public static void Initialize(TestContext context)
{
var testHandler = TestMessageHandler.FromResourceResponse("RouteFrom1172_34ToRedlandsCA");
var task = new RouteService(testHandler).GetRoute(
new MapPoint(-117.2, 34) { SpatialReference = SpatialReferences.Wgs84 },
new MapPoint(-117.18253721699972, 34.055566969000438) { SpatialReference = SpatialReferences.Wgs84 },
CancellationToken.None);
task.Wait();
route = task.Result;
}
public RouteResult Route(string path, HttpMethod method)
{
var result = new RouteResult();
if (this.table.TryGetValue(path, out var node))
{
result.Handler = node.Get(method);
}
return(result);
}
public RouteResult Route(ShardingRule shardingRule)
{
RouteResult result = new RouteResult();
foreach (var dataSourceName in shardingRule.ShardingDataSourceNames.DataSourceNames)
{
result.GetRouteUnits().Add(new RouteUnit(new RouteMapper(dataSourceName, dataSourceName), new List <RouteMapper>(0)));
}
return(result);
}
private ShardingContext(RouteResult routeResult)
{
foreach (var physicTable in routeResult.ReplaceTables)
{
_shardingTables.Add(physicTable.VirtualTable, new List <string>(1)
{
physicTable.Tail
});
}
}
public void ProcessRequest(HttpContext context)
{
Request = context.Request;
Response = context.Response;
string rootPath = Request.MapPath("~");
String StartIds = Request.QueryString["start"];
String EndIds = Request.QueryString["end"];
String[] StartArr = StartIds.Split(',');
String[] EndArr = EndIds.Split(',');
String retStr = "";
ArrayList retArr = new ArrayList();
try
{
for (int i = 0; i < StartArr.Length; i++)
{
for (int j = 0; j < EndArr.Length; j++)
{
List <RouteResult> RouteRs = GetAllRouteRs(StartArr[i], EndArr[j]);
for (int k = 0; k < RouteRs.Count; k++)
{
RouteResult RtRs = RouteRs[k];
retArr.Add(TranslateRtRs(RtRs));
}
}
}
string formater = "{{'NUM':'{0}','RESULTSET':[{1}]}}";
if (retArr.Count == 0)
{
retStr = string.Format(formater, "0", "");
}
else
{
string[] tmp = new string[retArr.Count];
retArr.CopyTo(tmp);
retStr = string.Format(formater, retArr.Count.ToString(), string.Join(",", tmp));
}
}
catch (Exception ex)
{
retStr = "alert('" + ex.Message + "!');";
}
finally
{
retStr = retStr.Trim();
//if (retStr.Length > 0)
//{
// retStr = retStr.Substring(0, retStr.Length - 1);
//}
Response.Write(retStr);
}
}
private void routeTask_SolveCompleted(object sender, RouteEventArgs e)
{
GraphicsLayer graphicsLayer = MyMap.Layers["MyRouteGraphicsLayer"] as GraphicsLayer;
RouteResult routeResult = e.RouteResults[0];
_directionsFeatureSet = routeResult.Directions;
graphicsLayer.Graphics.Add(new Graphic()
{
Geometry = _directionsFeatureSet.MergedGeometry, Symbol = LayoutRoot.Resources["RouteSymbol"] as ESRI.ArcGIS.Client.Symbols.Symbol
});
TotalDistanceTextBlock.Text = string.Format("Total Distance: {0}", FormatDistance(_directionsFeatureSet.TotalLength, "miles"));
TotalTimeTextBlock.Text = string.Format("Total Time: {0}", FormatTime(_directionsFeatureSet.TotalTime));
TitleTextBlock.Text = _directionsFeatureSet.RouteName;
int i = 1;
foreach (Graphic graphic in _directionsFeatureSet.Features)
{
System.Text.StringBuilder text = new System.Text.StringBuilder();
text.AppendFormat("{0}. {1}", i, graphic.Attributes["text"]);
if (i > 1 && i < _directionsFeatureSet.Features.Count)
{
string distance = FormatDistance(Convert.ToDouble(graphic.Attributes["length"]), "miles");
string time = null;
if (graphic.Attributes.ContainsKey("time"))
{
time = FormatTime(Convert.ToDouble(graphic.Attributes["time"]));
}
if (!string.IsNullOrEmpty(distance) || !string.IsNullOrEmpty(time))
{
text.Append(" (");
}
text.Append(distance);
if (!string.IsNullOrEmpty(distance) && !string.IsNullOrEmpty(time))
{
text.Append(", ");
}
text.Append(time);
if (!string.IsNullOrEmpty(distance) || !string.IsNullOrEmpty(time))
{
text.Append(")");
}
}
TextBlock textBlock = new TextBlock()
{
Text = text.ToString(), Tag = graphic, Margin = new Thickness(4), Cursor = Cursors.Hand
};
textBlock.MouseLeftButtonDown += new MouseButtonEventHandler(directionsSegment_MouseLeftButtonDown);
DirectionsStackPanel.Children.Add(textBlock);
i++;
}
MyMap.ZoomTo(Expand(_directionsFeatureSet.Extent));
}
private void routeTask_SolveCompleted(object sender, RouteEventArgs e)
{
GraphicsLayer routeLayer = MyMap.Layers["MyRouteGraphicsLayer"] as GraphicsLayer;
RouteResult routeResult = e.RouteResults[0];
routeResult.Route.Symbol = LayoutRoot.Resources["RouteSymbol"] as ESRI.ArcGIS.Client.Symbols.Symbol;
routeLayer.Graphics.Clear();
Graphic lastRoute = routeResult.Route;
routeLayer.Graphics.Add(lastRoute);
}
public void NumericId()
{
RouteResult routeResult = WebAppConfig.Router.Resolve("con/act/numericid/75");
Assert.AreEqual(routeResult.Controller, "con");
Assert.AreEqual(routeResult.Action, "act");
Assert.AreEqual(routeResult.Parameters["id"], "75");
routeResult = WebAppConfig.Router.Resolve("con/act/numericid/75a");
Assert.IsNull(routeResult);
}
/// <summary>
/// Initializes a new instance of the <see cref="RouteDataSource"/> class.
/// </summary>
/// <param name="route">The route.</param>
public RouteDataSource(RouteResult route)
{
m_route = route;
if (IsDesignMode) //Design time data
{
DistanceToDestination = 1000;
DistanceToWaypoint = 500;
TimeToWaypoint = new TimeSpan(1, 2, 3);
TimeToDestination = new TimeSpan(2, 3, 4);
NextManeuver = "Turn right onto Main St.";
}
}
public RouteResult Route(ShardingRule shardingRule)
{
RouteResult result = new RouteResult();
var logicTableNames = GetLogicTableNames();
foreach (var logicTableName in logicTableNames)
{
result.GetRouteUnits().AddAll(GetAllRouteUnits(shardingRule, logicTableName));
}
return(result);
}
private async Task FindRoute()
{
// Manage Buttons
AcceptNavigation.Visibility = Visibility.Visible;
AcceptNavigation.IsEnabled = true;
RefuseNavigation.Visibility = Visibility.Visible;
RefuseNavigation.IsEnabled = true;
CancelNavigation.Visibility = Visibility.Hidden;
CancelNavigation.IsEnabled = false;
TripRequestTB.Visibility = Visibility.Visible;
try
{
_solveRouteTask = await RouteTask.CreateAsync(_transportationNetwork);
_routeParameters = await _solveRouteTask.CreateDefaultParametersAsync();
var truckMode = from travelmode in _solveRouteTask.RouteTaskInfo.TravelModes
where travelmode.Type == "TRUCK"
select travelmode;
_routeParameters.TravelMode = truckMode.Last();
_routeParameters.ReturnDirections = true;
_routeParameters.ReturnStops = true;
_routeParameters.ReturnRoutes = true;
_routeParameters.OutputSpatialReference = SpatialReferences.Wgs84;
List <Stop> stops = new List <Stop> {
new Stop(_mapView.LocationDisplay.MapLocation),
new Stop(_startPoint)
};
_routeParameters.SetStops(stops);
_routeResult = await _solveRouteTask.SolveRouteAsync(_routeParameters);
_route = _routeResult.Routes.FirstOrDefault();
// Display UI info
TimeTB = _route.TotalTime.ToString(@"hh\:mm\:ss");
DistanceTB = Math.Round(_route.TotalLength / 1000, 2).ToString();
// Diplay the route
Polyline routePolyline = _route.RouteGeometry;
SimpleLineSymbol routeSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.BlueViolet, 4.0f);
Graphic routeGraphic = new Graphic(routePolyline, routeSymbol);
_graphicsOverlay.Graphics.Add(routeGraphic);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
setExtent(_mapView.LocationDisplay.MapLocation, _startPoint);
//StartNavigation();
}
public RouteResult Route(ShardingRule shardingRule)
{
RouteResult result = new RouteResult();
ICollection <ISet <string> > broadcastDataSourceGroup = GetBroadcastDataSourceGroup(GetDataSourceGroup(shardingRule));
foreach (var broadcastDataSource in broadcastDataSourceGroup)
{
var dataSourceName = GetRandomDataSourceName(broadcastDataSource);
result.GetRouteUnits().Add(new RouteUnit(new RouteMapper(dataSourceName, dataSourceName), new List <RouteMapper>(0)));
}
return(result);
}
public void TestRemoveRoute()
{
var endpoint1 = new TestEndpoint("id1");
var endpoint2 = new TestEndpoint("id2");
var result1 = new RouteResult(endpoint1, 0, 0);
var result2 = new RouteResult(endpoint2, 0, 0);
var allEndpoints = new HashSet <Endpoint> {
endpoint1, endpoint2
};
var route1 = new Route("id1", "false", "hub", TelemetryMessageSource.Instance, endpoint1, 0, 0);
var route2 = new Route("id2", "true", "hub", TelemetryMessageSource.Instance, endpoint2, 0, 0);
var route3 = new Route("id3", "true", "hub", TelemetryMessageSource.Instance, endpoint1, 0, 0);
var routes = new HashSet <Route> {
route2, route1, route3
};
var evaluator = new Evaluator(new RouterConfig(allEndpoints, routes));
ISet <RouteResult> results = evaluator.Evaluate(Message1);
Assert.Equal(2, results.Count);
Assert.Contains(result2, results);
Assert.Contains(result1, results);
Assert.True(routes.SetEquals(evaluator.Routes));
// Remove route2
evaluator.RemoveRoute("id2");
results = evaluator.Evaluate(Message1);
Assert.Equal(1, results.Count);
Assert.Contains(result1, results);
Assert.True(evaluator.Routes.SetEquals(new HashSet <Route> {
route3, route1
}));
// Remove route3
evaluator.RemoveRoute("id3");
results = evaluator.Evaluate(Message1);
Assert.Equal(0, results.Count);
Assert.DoesNotContain(result1, results);
Assert.True(evaluator.Routes.SetEquals(new HashSet <Route> {
route1
}));
// Remove route3 again
evaluator.RemoveRoute("id3");
results = evaluator.Evaluate(Message1);
Assert.Equal(0, results.Count);
Assert.DoesNotContain(result1, results);
Assert.True(evaluator.Routes.SetEquals(new HashSet <Route> {
route1
}));
}
private void MyRouteTask_SolveCompleted(object sender, RouteEventArgs e)
{
routeGraphicsLayer.Graphics.Clear();
RouteResult routeResult = e.RouteResults[0];
Graphic lastRoute = routeResult.Route;
decimal totalTime = (decimal)lastRoute.Attributes["Total_TravelTime"];
TotalTimeTextBlock.Text = string.Format("Total time: {0} minutes", totalTime.ToString("#0.000"));
routeGraphicsLayer.Graphics.Add(lastRoute);
}
public void StartPathing(ActorSpawner s)
{
router = new Router();
spawner = s;
Vector3 pos = startingNode.transform.position;
transform.position = pos;
Node targetNode = spawner.RandomNode();
// now we have the route
route = router.Route(startingNode, targetNode);
}
public RouteResult Route(ShardingRule shardingRule)
{
RouteResult result = new RouteResult();
var dataSourceLogicTablesMap = GetDataSourceLogicTablesMap();
foreach (var dataSourceLogicTableMap in dataSourceLogicTablesMap)
{
List <ISet <String> > actualTableGroups = GetActualTableGroups(dataSourceLogicTableMap.Key, dataSourceLogicTableMap.Value);
List <ISet <RouteMapper> > routingTableGroups = ToRoutingTableGroups(dataSourceLogicTableMap.Key, actualTableGroups);
result.GetRouteUnits().AddAll(GetRouteUnits(dataSourceLogicTableMap.Key, routingTableGroups.Cartesian().Select(o => o.ToList()).ToHashSet()));
}
return(result);
}
public RouteResult Route(ShardingRule shardingRule)
{
RouteResult result = new RouteResult();
List <RouteMapper> routingTables = new List <RouteMapper>(_logicTables.Count);
foreach (var logicTable in _logicTables)
{
routingTables.Add(new RouteMapper(logicTable, logicTable));
}
String dataSourceName = shardingRule.ShardingDataSourceNames.GetDefaultDataSourceName();
result.GetRouteUnits().Add(new RouteUnit(new RouteMapper(dataSourceName, dataSourceName), routingTables));
return(result);
}
private async Task CalculateRouteAsync()
{
try
{
progress.Visibility = Visibility.Visible;
RouteParameters routeParams = await _routeTask.GetDefaultParametersAsync();
routeParams.OutSpatialReference = MyMapView.SpatialReference;
routeParams.ReturnDirections = false;
routeParams.SetStops(_stopsGraphicsOverlay.Graphics);
RouteResult routeResult = await _routeTask.SolveAsync(routeParams);
if (routeResult.Routes.Count > 0)
{
_routeGraphicsOverlay.Graphics.Clear();
var route = routeResult.Routes.First().RouteFeature;
_routeGraphicsOverlay.Graphics.Add(new Graphic(route.Geometry));
var meters = GeometryEngine.GeodesicLength(route.Geometry, GeodeticCurveType.Geodesic);
txtDistance.Text = string.Format("{0:0.00} miles", LinearUnits.Miles.ConvertFromMeters(meters));
panelRouteInfo.Visibility = Visibility.Visible;
}
}
catch (AggregateException ex)
{
var innermostExceptions = ex.Flatten().InnerExceptions;
if (innermostExceptions != null && innermostExceptions.Count > 0)
{
MessageBox.Show(innermostExceptions[0].Message);
}
else
{
MessageBox.Show(ex.Message);
}
}
catch (System.Exception ex)
{
MessageBox.Show("Error: " + ex.Message);
}
finally
{
progress.Visibility = Visibility.Collapsed;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RouteLocationSimulator"/> class.
/// </summary>
/// <param name="route">The route to use for simulation. The spatial reference of the route
/// must be in geographic coordinates (WGS84).</param>
/// <param name="startPoint">An optional starting point.</param>
public RouteLocationSimulator(RouteResult route, MapPoint startPoint = null)
{
if (route == null)
throw new ArgumentNullException("route");
m_route = route;
timer = new DispatcherTimer() { Interval = TimeSpan.FromSeconds(1) };
if (startPoint == null)
{
startPoint = new MapPoint((route.Routes.First().RouteGraphic.Geometry as Polyline).Paths[0][0], SpatialReferences.Wgs84);
}
timer.Tick += timer_Tick;
Speed = 50; // double.NaN;
directionIndex = 0;
lineLength = 0;// GeometryEngine.GeodesicLength(route.Directions.First().MergedGeometry);
drivePath = route.Routes.First().RouteGraphic.Geometry as Polyline;
}
/// <summary>
/// Initializes a new instance of the <see cref="RouteLocationSimulator"/> class.
/// </summary>
/// <param name="route">The route to use for simulation. The spatial reference of the route
/// must be in geographic coordinates (WGS84).</param>
/// <param name="startPoint">An optional starting point.</param>
public RouteLocationSimulator(RouteResult route, MapPoint startPoint = null)
{
if (route == null)
throw new ArgumentNullException("route");
m_route = route;
timer = new DispatcherTimer() { Interval = TimeSpan.FromSeconds(1) };
if (startPoint == null)
{
startPoint = (route.Routes.First().RouteFeature.Geometry as Polyline).Parts.GetPartsAsPoints().First().First();
}
timer.Tick += timer_Tick;
Speed = 50;
directionIndex = 0;
lineLength = 0;
drivePath = route.Routes.First().RouteFeature.Geometry as Polyline;
}
/// <summary>
/// Initializes a new instance of the <see cref="RouteDataSource"/> class.
/// </summary>
/// <param name="route">The route.</param>
public RouteDataSource(RouteResult route)
{
m_route = route;
if (IsDesignMode) //Design time data
{
DistanceToDestination = 1000;
DistanceToWaypoint = 500;
TimeToWaypoint = new TimeSpan(1, 2, 3);
TimeToDestination = new TimeSpan(2, 3, 4);
NextManeuver = "Turn right onto Main St.";
}
else
{
InitializeRoute();
}
}
public void ReturnsFalseWhenTheExceptionPropertyIsNotNull()
{
var result = new RouteResult(new Exception());
Assert.That(result.Success, Is.False);
}
public void ReturnsTrueWhenTheMessagePropertyIsNotNull()
{
var result = new RouteResult(new TestMessage(), null);
Assert.That(result.Success, Is.True);
}
// ***********************************************************************************
// * Initialize Find Closest Facility Result View
// ***********************************************************************************
public FindCloseFacilityResultView(FindClosestResourceToolbar findClosestToolbar, RouteResult[] routeResults, MapWidget mapWidget)
{
InitializeComponent();
base.DataContext = this;
// Store a reference to the MapWidget that the toolbar has been installed to.
_mapWidget = mapWidget;
_dirSummary = new DirectionSummary();
_dirSummary.From = "From";
_dirSummary.To = "To";
_dirSummary.FieldType = "FieldType";
_dirSummary.Rank = "Rank";
_dirSummary.TotalTime = "Total Time";
_dirSummary.TotalLength = "Total Length";
_directions.Add(_dirSummary);
_closestFacilityToolbar = findClosestToolbar;
// add each route result to the result dialog.
foreach(RouteResult routeResult in routeResults)
{
DirectionsFeatureSet directionsFS = routeResult.Directions;
string routeName = directionsFS.RouteName;
int j = routeName.IndexOf("-");
_dirSummary = new DirectionSummary();
_dirSummary.From = routeName.Substring(0, j - 1);
_dirSummary.To = routeName.Substring(j + 2);
_dirSummary.FieldType = _closestFacilityToolbar.FacilityType;
_dirSummary.Rank = directionsFS.RouteID.ToString();
_dirSummary.TotalTime = directionsFS.TotalDriveTime.ToString("0.0") + " minutes";
_dirSummary.TotalLength = directionsFS.TotalLength.ToString("0.0") + " miles";
_dirSummary.SelectedRoute = routeResult;
_directions.Add(_dirSummary);
}
}
