private DirectionsResponse GetDirectionsResponse(Entry from, Entry to)
{
var cacheKey = from.ToString() + "-" + to.ToString() + "-directions";
var cachedVal = FindInCache <DirectionsResponse>(cacheKey);
if (cachedVal != null)
{
return(cachedVal);
}
var directionsRequest = new DirectionsRequest {
Origin = from.Where.Name, Destination = to.Where.Name
};
directionsRequest.ApiKey = this.apikey;
DirectionsResponse directions = GoogleMaps.Directions.Query(directionsRequest);
if (directions.Status == DirectionsStatusCodes.OK)
{
return(AddToCache(cacheKey, directions));
}
return(null);
}
/* This function was written by Lennart de Waart (563079) */
/// <summary>
/// Public asynchronous method that returns the optimal Leg class between two points.
/// </summary>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="vehicle"></param>
/// <param name="departureTime">Time when person starts driving</param>
/// <param name="apiKey"></param>
/// <returns>Filled Leg class or null</returns>
public async Task <Leg> TravelTo(LatLng from, LatLng to, Vehicles vehicle, DateTime departureTime, string apiKey)
{
try
{
_logger.Information($"A request has been made to get the Leg of a route between latFrom {from.Latitude}, longFrom {from.Longitude}" +
$"and latTo {to.Latitude}, longTo {to.Longitude} from the Google Directions API.");
// Set travel mode based on vehicle parameter
TravelMode t = TravelMode.Driving;
if (vehicle == Vehicles.Fiets)
{
t = TravelMode.Bicycling;
}
// Create a DirectionsRequest
DirectionsRequest d = new DirectionsRequest
{
TravelMode = t,
DepartureTime = departureTime,
Origin = new GoogleApi.Entities.Common.Location(from.Latitude, from.Longitude),
Destination = new GoogleApi.Entities.Common.Location(to.Latitude, to.Longitude),
Key = apiKey
};
// POST request to Google Directions API
DirectionsResponse r = await GoogleMaps.Directions.QueryAsync(d);
// Response contains a list of routes to the destination. A route contains multiple legs of ways to get to the destination. Get the first (and best)
Leg results = r.Routes.ToList()[0].Legs.ToList()[0];
return(results ?? throw new Exception($"Dependency failure: Google Directions API request returned null for latFrom " +
$"{from.Latitude}, longFrom {from.Longitude} to latTo {to.Latitude}, longTo {to.Longitude}."));
}
catch (Exception e) // Error handling
{
_logger.Error($"ILocationsService says: {e.Message} Exception occured on line {new StackTrace(e, true).GetFrame(0).GetFileLineNumber()}.");
return(null);
}
}
private double _CalculateDrivingTime(LatLong origin, LatLong destination)
{
try
{
var transitDirectionRequest = new DirectionsRequest
{
Origin = string.Format("{0},{1}", origin.Latitude, origin.Longitude),
Destination = string.Format("{0},{1}", destination.Latitude, destination.Longitude),
TravelMode = TravelMode.Driving,
DepartureTime = DateTime.Now
};
DirectionsResponse transitDirections = GoogleMaps.Directions.Query(transitDirectionRequest);
if (transitDirections.Status == DirectionsStatusCodes.OK)
{
double totalTime = 0;
foreach (var route in transitDirections.Routes)
{
foreach (var routeLeg in route.Legs)
{
totalTime += routeLeg.Duration.Value.TotalSeconds;
}
}
return(totalTime / 3600.0);
}
}
catch (Exception)
{
}
return(0);
}
public void TestConnectivityWithNoKey()
{
DirectionsResponse directionsResponse = new DirectionsRequest()
{
Key = Environment.GetEnvironmentVariable("GOOGLE_MAP_KEY"),
Origin = new LocationParameter()
{
LatLongPair = new LatLongPair()
{
Latitude = 40.6700,
Longitude = -73.9400
}
},
Destination = new LocationParameter()
{
LatLongPair = new LatLongPair()
{
Latitude = 40.6860,
Longitude = -73.9450
}
}, _DepartureTime = DateTime.Now + TimeSpan.FromDays(10)
}.GetDirections();
Assert.IsTrue(directionsResponse.Successfull);
}
public void GetQueryStringParametersWhenTravelModeTransitTest()
{
var request = new DirectionsRequest
{
Key = "key",
Origin = new LocationEx(new Address("address")),
Destination = new LocationEx(new Address("address")),
TravelMode = TravelMode.Transit
};
var queryStringParameters = request.GetQueryStringParameters();
Assert.IsNotNull(queryStringParameters);
var mode = queryStringParameters.FirstOrDefault(x => x.Key == "mode");
var modeExpected = request.TravelMode.ToString().ToLower();
Assert.IsNotNull(mode);
Assert.AreEqual(modeExpected, mode.Value);
var transitMode = queryStringParameters.FirstOrDefault(x => x.Key == "transit_mode");
var transitModeExpected = request.TransitMode.ToEnumString('|');
Assert.IsNotNull(transitMode);
Assert.AreEqual(transitModeExpected, transitMode.Value);
var departureTime = queryStringParameters.FirstOrDefault(x => x.Key == "departure_time");
const string DEPARTURE_TIME_EXPECTED = "now";
Assert.IsNotNull(departureTime);
Assert.AreEqual(DEPARTURE_TIME_EXPECTED, departureTime.Value);
}
public void GetQueryStringParametersWhenTravelModeTransitAndDepartureTimeTest()
{
var request = new DirectionsRequest
{
Key = "key",
Origin = new LocationEx(new Address("address")),
Destination = new LocationEx(new Address("address")),
TravelMode = TravelMode.Transit,
DepartureTime = DateTime.UtcNow.AddHours(1)
};
var queryStringParameters = request.GetQueryStringParameters();
Assert.IsNotNull(queryStringParameters);
var mode = queryStringParameters.FirstOrDefault(x => x.Key == "mode");
var modeExpected = request.TravelMode.ToString().ToLower();
Assert.IsNotNull(mode);
Assert.AreEqual(modeExpected, mode.Value);
var transitMode = queryStringParameters.FirstOrDefault(x => x.Key == "transit_mode");
var transitModeExpected = request.TransitMode.ToEnumString('|');
Assert.IsNotNull(transitMode);
Assert.AreEqual(transitModeExpected, transitMode.Value);
var departureTime = queryStringParameters.FirstOrDefault(x => x.Key == "departure_time");
var departureTimeExpected = request.DepartureTime.GetValueOrDefault().DateTimeToUnixTimestamp().ToString(CultureInfo.InvariantCulture);
Assert.IsNotNull(departureTime);
Assert.AreEqual(departureTimeExpected, departureTime.Value);
}
public async Task <RouteEM> GetRoute(Coordinate origin, Coordinate destination, IEnumerable <Coordinate> waypoints)
{
var result = new RouteEM();
var directionRequest = new DirectionsRequest
{
Key = GoogleConfig.ApiKey,
Origin = origin.ToLocation(),
Destination = destination.ToLocation(),
Waypoints = waypoints.Select(p => p.ToLocation()).ToArray(),
Language = Language.Russian,
OptimizeWaypoints = false
};
var directionResponse = await GoogleMaps.Directions.QueryAsync(directionRequest);
result.Status = (Status)directionResponse.Status;
var firstRoute = directionResponse.Routes.FirstOrDefault();
if (firstRoute != null)
{
foreach (var leg in firstRoute.Legs)
{
result.Legs.Add(LegFromGoogleLeg(leg));
}
}
return(result);
}
public async Task <DirectionsResponse> GetDirections(DirectionsRequest directionsRequest)
{
try
{
using (var client = new HttpClient())
{
client.BaseAddress = _baseUri;
var response = await client.GetAsync(_baseUri + constructUriParameters(directionsRequest));
if (!response.IsSuccessStatusCode)
{
throw new Exception($"{response.StatusCode}: {response.ReasonPhrase}");
}
var responseString = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <DirectionsResponse>(responseString));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
if (ex.InnerException != null)
{
Console.WriteLine(ex.InnerException.Message);
Console.WriteLine(ex.InnerException.StackTrace);
}
return(new DirectionsResponse());
}
}
private double _CalculateDistance(LatLong origin, LatLong destination)
{
try
{
var transitDirectionRequest = new DirectionsRequest
{
Origin = string.Format("{0},{1}", origin.Latitude, origin.Longitude),
Destination = string.Format("{0},{1}", destination.Latitude, destination.Longitude),
TravelMode = TravelMode.Driving,
DepartureTime = DateTime.Now
};
DirectionsResponse transitDirections = GoogleMaps.Directions.Query(transitDirectionRequest);
if (transitDirections.Status == DirectionsStatusCodes.OK)
{
int distanceMeters = 0;
foreach (var route in transitDirections.Routes)
{
foreach (var routeLeg in route.Legs)
{
distanceMeters += routeLeg.Distance.Value;
}
}
return(distanceMeters / 1000.00);
}
}
catch (Exception ex)
{
}
return(0);
}
public void GetQueryStringParametersWhenTravelModeDrivingAndDepartureTimeAndTrafficModelAndWayPointsViaTest()
{
var request = new DirectionsRequest
{
Key = "key",
Origin = new LocationEx(new Address("address")),
Destination = new LocationEx(new Address("address")),
TravelMode = TravelMode.Driving,
DepartureTime = DateTime.UtcNow.AddHours(1),
TrafficModel = TrafficModel.Best_Guess,
WayPoints = new[]
{
new WayPoint(new LocationEx(new Address("waypoint_address")), true)
}
};
var queryStringParameters = request.GetQueryStringParameters();
Assert.IsNotNull(queryStringParameters);
var departureTime = queryStringParameters.FirstOrDefault(x => x.Key == "departure_time");
var departureTimeExpected = request.DepartureTime.GetValueOrDefault().DateTimeToUnixTimestamp().ToString(CultureInfo.InvariantCulture);
Assert.IsNotNull(departureTime);
Assert.AreEqual(departureTimeExpected, departureTime.Value);
var trafficModel = queryStringParameters.FirstOrDefault(x => x.Key == "traffic_model");
var trafficModelExpected = request.TrafficModel.ToString().ToLower();
Assert.IsNotNull(trafficModel);
Assert.AreEqual(trafficModelExpected, trafficModel.Value);
}
private double _CalculateTransit(LatLong origin, LatLong destination, DateTime depTime)
{
try
{
var transitDirectionRequest = new DirectionsRequest
{
Origin = string.Format("{0},{1}", origin.Latitude, origin.Longitude),
Destination = string.Format("{0},{1}", destination.Latitude, destination.Longitude),
TravelMode = TravelMode.Transit,
DepartureTime = depTime,
ApiKey = GoogleKey
};
DirectionsResponse transitDirections = GoogleMaps.Directions.Query(transitDirectionRequest);
if (transitDirections.Status == DirectionsStatusCodes.OK)
{
string jsonStr = JsonConvert.SerializeObject(transitDirections);
return(0);
}
}
catch (Exception)
{
}
return(0);
}
public async Task <RouteInformation> GetRoute(double startLat, double startLon, double endLat, double endLon)
{
DirectionsRequest directionsRequest = new DirectionsRequest()
{
Origin = string.Format("{0},{1}", startLat, startLon),
Destination = string.Format("{0},{1}", endLat, endLon),
ApiKey = Config.MappingConfig.GoogleMapsApiKey
};
async Task <RouteInformation> getRoute()
{
DirectionsResponse directions = await GoogleMapsApi.GoogleMaps.Directions.QueryAsync(directionsRequest);
var info = new RouteInformation();
if (directions != null && directions.Status == DirectionsStatusCodes.OK)
{
var route = directions.Routes.FirstOrDefault();
if (route != null)
{
info.Name = route.Summary;
info.ProcessedOn = DateTime.UtcNow;
info.Successful = true;
}
}
return(info);
};
return(await _cacheProvider.RetrieveAsync <RouteInformation>(string.Format(RouteCacheKey, string.Format("{0}{1}", startLat, startLon).GetHashCode(), string.Format("{0}{1}", endLat, endLon).GetHashCode()), getRoute, CacheLength));
}
public static string GetTravelTime(string origin, string dest = "50.0154346,36.2284612")
{
StringBuilder result = new StringBuilder();
DirectionsRequest directionsRequest = new DirectionsRequest()
{
Origin = origin,
Destination = dest,
ApiKey = "AIzaSyDgjuPVvAcN9RtqgFc35OhxJPXNjQ_ugPM",
Language = "ru",
TravelMode = TravelMode.Transit,
DepartureTime = DateTime.Now.AddMinutes(10),
};
DirectionsResponse directions = GoogleMaps.Directions.Query(directionsRequest);
var route = directions.Routes.First().Legs.First();
StaticMapsEngine staticMapGenerator = new StaticMapsEngine();
IEnumerable <Step> steps = route.Steps;
IList <ILocationString> path = steps.Select(step => step.StartLocation).ToList <ILocationString>();
path.Add(steps.Last().EndLocation);
string url =
$"https://www.google.com.ua/maps/dir/'{origin}'/{dest}'";
result.AppendLine($"Отлично, от вас до ВУЗа {route.Distance.Text}");
result.AppendLine($"Если выйти через 10 минут, то можно добратся за {route.Duration.Text}");
result.AppendLine($"В ВУЗе вы будете около {route.ArrivalTime.Text}");
result.AppendLine($"Вот оптимальный маршрут для тебя {url}");
return(result.ToString());
}
protected void btnTestar_Click(Object sender, EventArgs e)
{
var geocodingRequest = new GeocodingRequest {
Location = new Location(-19.904356, -43.925691)
};
GeocodingResponse geocodingResponse = GoogleMaps.Geocode.Query(geocodingRequest);
if (geocodingResponse != null && geocodingResponse.Status == Status.OK)
{
var drivingDirectionRequest = new DirectionsRequest
{
Origin = ObterEndereco(geocodingResponse),
Destination = "Avenida Amazonas 7000, Belo Horizonte, MG, Brazil",
Sensor = false,
Alternatives = false
};
DirectionsResponse drivingDirections = GoogleMaps.Directions.Query(drivingDirectionRequest);
if (drivingDirections != null && drivingDirections.Status == DirectionsStatusCodes.OK)
{
lblDistancia.Text = string.Format("Distância Total: {0} m.", ObterDistanciaTotal(drivingDirections).ToString());
}
}
}
/// <summary>
/// use Google Api to get distance between two address stored in strings
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public float distanceBetweenAddresses(string source, string dest)
{
// in case at least one address is empty - return immediately
if (source == null || dest == null)
{
return(-1);
}
var drivingDirectionRequest = new DirectionsRequest
{
TravelMode = TravelMode.Walking,
Origin = source,
Destination = dest,
};
DirectionsResponse drivingDirections = GoogleMaps.Directions.Query(drivingDirectionRequest);
if (drivingDirections.Routes.ElementAtOrDefault(0) == null)
{
return(-1);
}
Route route = drivingDirections.Routes.First();
Leg leg = route.Legs.First();
return(Convert.ToSingle(leg.Distance.Value / 1000.0));
}
public static CoordGoogleResponse Send(this DirectionsRequest req, Vehicle v, string serviceScope = "")
{
CoordGoogleRequest coordGoogleRequest = JsonConvert.DeserializeObject <CoordGoogleRequest>(JsonConvert.SerializeObject(req));
coordGoogleRequest.Vehicle = v;
return(coordGoogleRequest.Send(serviceScope));
}
public void Directions_WithIcons()
{
var depTime = DateTime.Today
.AddDays(1)
.AddHours(13);
var request = new DirectionsRequest
{
Origin = "T-centralen, Stockholm, Sverige",
Destination = "Kungsträdgården, Stockholm, Sverige",
TravelMode = TravelMode.Transit,
DepartureTime = depTime,
Language = "sv",
ApiKey = ApiKey
};
DirectionsResponse result = GoogleMaps.Directions.Query(request);
AssertInconclusive.NotExceedQuota(result);
var route = result.Routes.First();
var leg = route.Legs.First();
var steps = leg.Steps;
Assert.IsNotEmpty(steps.Where(s =>
s.TransitDetails?
.Lines?
.Vehicle?
.Icon != null));
}
public void Directions_ExceedingRouteLength()
{
var request = new DirectionsRequest
{
Origin = "NYC, USA", Destination = "Miami, USA", Waypoints = new string[]
{
"Seattle, USA",
"Dallas, USA",
"Naginey, USA",
"Edmonton, Canada",
"Seattle, USA",
"Dallas, USA",
"Naginey, USA",
"Edmonton, Canada",
"Seattle, USA",
"Dallas, USA",
"Naginey, USA",
"Edmonton, Canada"
},
ApiKey = ApiKey
};
var result = GoogleMaps.Directions.Query(request);
AssertInconclusive.NotExceedQuota(result);
Assert.AreEqual(DirectionsStatusCodes.MAX_ROUTE_LENGTH_EXCEEDED, result.Status, result.ErrorMessage);
}
public List <Nanny> DistanceNannys(Mother mother)//this function find all the nannys with distans of 1 KM from mammy
{
List <Nanny> distanceNannys = new List <Nanny>();
foreach (Nanny nanny in GetNannys())
{
string motherAddress = mother.BabbySitterAdress.ToString();
if (motherAddress == null)
{
motherAddress = mother.Address.ToString();
}
var walkingDirectionRequest = new DirectionsRequest
{
TravelMode = TravelMode.Walking,
Origin = motherAddress,
Destination = nanny.Address.ToString()
};
DirectionsResponse walkingDirections = GoogleMaps.Directions.Query(walkingDirectionRequest);
Route route = walkingDirections.Routes.First();
Leg leg = route.Legs.First();
if (leg.Distance.Value < 1000)
{
distanceNannys.Add(nanny);
}
}
return(distanceNannys);
}
public void Directions_VerifyBounds()
{
var request = new DirectionsRequest
{
Origin = "Genk, Belgium",
Destination = "Brussels, Belgium",
TravelMode = TravelMode.Driving,
ApiKey = ApiKey
};
DirectionsResponse result = GoogleMaps.Directions.Query(request);
AssertInconclusive.NotExceedQuota(result);
var route = result.Routes.First();
Assert.NotNull(route);
Assert.NotNull(route.Bounds);
Assert.Greater(route.Bounds.NorthEast.Latitude, 50);
Assert.Greater(route.Bounds.NorthEast.Longitude, 3);
Assert.Greater(route.Bounds.SouthWest.Latitude, 50);
Assert.Greater(route.Bounds.SouthWest.Longitude, 3);
Assert.Greater(route.Bounds.Center.Latitude, 50);
Assert.Greater(route.Bounds.Center.Longitude, 3);
}
public void DirectionsWhenWayÆointsAndOptimizeWaypointsTest()
{
var request = new DirectionsRequest
{
Key = this.ApiKey,
Origin = new Location("NYC, USA"),
Destination = new Location("Miami, USA"),
Waypoints = new[] { new Location("Philadelphia, USA") },
OptimizeWaypoints = true
};
var result = GoogleMaps.Directions.Query(request);
Assert.IsNotNull(result);
Assert.AreEqual(Status.Ok, result.Status);
var route = result.Routes.FirstOrDefault();
Assert.IsNotNull(route);
var leg = route.Legs.FirstOrDefault();
Assert.IsNotNull(leg);
Assert.AreEqual(156084, leg.Steps.Sum(s => s.Distance.Value), 15000);
Assert.IsTrue(leg.EndAddress.Contains("Philadelphia"));
}
public Route GetRoute(string origin, string dest)
{
var directionsRequest = new DirectionsRequest()
{
ApiKey = "AIzaSyAOzM-wrIj6ANCLEf3XI37mPc_JH0LDx5U",
Origin = origin,
Destination = dest,
};
DirectionsResponse directions = GoogleMaps.Directions.Query(directionsRequest);
if (!directions.Routes.Any() || !directions.Routes.First().Legs.Any())
{
return(null);
}
var leg = directions.Routes.First().Legs.First();
var distanceInMeters = (double)leg.Distance.Value;
var distanceInMiles = distanceInMeters * 0.000621371192237;
var durationInMinutes = leg.Duration.Value.TotalMinutes;
return(new Route {
DistanceInMiles = distanceInMiles, DurationInMinutes = durationInMinutes
});
}
public void BuildDirectionsUrl_ShouldFail_ForInvalidRequest()
{
var request = new DirectionsRequest();
var result = DirectionsUrlFactory.BuildDirectionsUrl(request, "APIKEY");
Assert.True(result.IsFailure);
}
private void _SaveTransitDetails(int originId, int destinationId, DateTime depTime)
{
try
{
using (TravelogyDevEntities1 context = new TravelogyDevEntities1())
{
var origin = context.Places.Find(originId);
var destination = context.Places.Find(destinationId);
if (origin == null || destination == null)
{
return;
}
var transitDirectionRequest = new DirectionsRequest
{
Origin = origin.Name,
Destination = destination.Name,
TravelMode = TravelMode.Transit,
DepartureTime = depTime,
ApiKey = GoogleKey
};
DirectionsResponse transitDirections = GoogleMaps.Directions.Query(transitDirectionRequest);
if (transitDirections.Status == DirectionsStatusCodes.OK)
{
string jsonStr = JsonConvert.SerializeObject(transitDirections);
string transitStart = transitDirections.Routes.FirstOrDefault().Legs.FirstOrDefault().DepartureTime.Text;
var _dbVal = context.Transits.Where(p => p.SourceId == originId &&
p.DestinationId == destinationId &&
p.departure_time == transitStart);
if (_dbVal.Count() == 0)
{
var _transitDetail = new Transit();
_transitDetail.SourceId = originId;
_transitDetail.DestinationId = destinationId;
_transitDetail.Distance = transitDirections.Routes.FirstOrDefault().Legs.FirstOrDefault().Distance.Value / 1000;
_transitDetail.departure_time = transitStart;
_transitDetail.arrival_time = transitDirections.Routes.FirstOrDefault().Legs.FirstOrDefault().ArrivalTime.Text;
_transitDetail.Transit_Time = (decimal)transitDirections.Routes.FirstOrDefault().Legs.FirstOrDefault().Duration.Value.TotalHours;
context.Transits.Add(_transitDetail);
context.SaveChanges();
}
}
}
}
catch (Exception ex)
{
string _debug = ex.Message;
}
}
private static void addStudentHomeMapMarker(DirectionsRequest directionsRequest, List <MapMarker> mapMarkers)
{
mapMarkers.Add(new MapMarker // Home
{
Color = MapFeatureColor.Blue,
Label = 'H',
Address = directionsRequest.OriginLocation.Address,
Coordinates = directionsRequest.OriginLocation.Coordinates
});
}
public async Task <IActionResult> Post([FromBody] DirectionsRequest directionsRequest)
{
var directions = await _mapService.GetDirections(directionsRequest);
if (directions == null)
{
return(NotFound());
}
return(Ok(directions));
}
public void GetQueryStringParametersTest()
{
var request = new DirectionsRequest
{
Origin = new Location("test"),
Destination = new Location("test")
};
Assert.DoesNotThrow(() => request.GetQueryStringParameters());
}
private static void addSchoolMapMarker(DirectionsRequest directionsRequest, List <MapMarker> mapMarkers)
{
mapMarkers.Add(new MapMarker // School
{
Color = MapFeatureColor.Blue,
Label = 'S',
Address = directionsRequest.DestinationLocation.Address,
Coordinates = directionsRequest.DestinationLocation.Coordinates
});
}
public async Task <DirectionsResult> GetTransitAsync(DirectionsRequest request)
{
Coordinate from, to;
ResolvedLocation resolvedStart, resolvedEnd = null;
if (request.UserId != null)
{
var locationBias = (await locationsService.ResolveAsync(request.UserId, new UnresolvedLocation(UnresolvedLocation.Home))) ?? Vienna;
resolvedStart = await locationsService.ResolveAsync(request.UserId, request.StartAddress, locationBias);
if (null != resolvedStart)
{
resolvedEnd = await locationsService.ResolveAsync(request.UserId, request.EndAddress, resolvedStart);
}
}
else
{
var locationBias = Vienna;
resolvedStart = await locationsService.ResolveAnonymousAsync(request.StartAddress, locationBias);
if (null != resolvedStart)
{
resolvedEnd = await locationsService.ResolveAnonymousAsync(request.EndAddress, resolvedStart);
}
}
if (null == resolvedStart)
{
throw new LocationNotFoundException(request.StartAddress);
}
if (null == resolvedEnd)
{
throw new LocationNotFoundException(request.EndAddress);
}
from = resolvedStart.Coordinate;
to = resolvedEnd.Coordinate;
var plan = await transitDirectionProvider.GetDirectionsAsync(new TransitDirectionsRequest
{
ArriveBy = request.ArriveBy,
DateTime = request.DateTime,
From = from,
To = to
});
if (null == plan)
{
return(null);
}
await directionsCache.PutAsync(plan.Id, plan);
return(new DirectionsResult()
{
CacheKey = plan.Id,
TransitDirections = plan.GetTransitDirections()
});
}
public void GetQueryStringParametersWhenKeyIsEmptyTest()
{
var request = new DirectionsRequest
{
Key = string.Empty
};
var exception = Assert.Throws <ArgumentException>(() => request.GetQueryStringParameters());
Assert.AreEqual("'Key' is required", exception.Message);
}
