public void GetQueryStringParametersTest()
{
var request = new AddressGeocodeRequest
{
Key = "key",
Address = "address"
};
var queryStringParameters = request.GetQueryStringParameters();
Assert.IsNotNull(queryStringParameters);
var key = queryStringParameters.SingleOrDefault(x => x.Key == "key");
var keyExpected = request.Key;
Assert.IsNotNull(key);
Assert.AreEqual(keyExpected, key.Value);
var language = queryStringParameters.SingleOrDefault(x => x.Key == "language");
var languageExpected = request.Language.ToCode();
Assert.IsNotNull(language);
Assert.AreEqual(languageExpected, language.Value);
var address = queryStringParameters.SingleOrDefault(x => x.Key == "address");
var addressExpected = request.Address;
Assert.IsNotNull(address);
Assert.AreEqual(addressExpected, address.Value);
}
/* This function was written by Lennart de Waart (563079) */
/// <summary>
/// Get latitude and longitude from an address.
/// GoogleApi source: https://github.com/vivet/GoogleApi
/// </summary>
/// <param name="address"></param>
/// <param name="apiKey"></param>
/// <returns>Filled LatLng class or null</returns>
public async Task <LatLng> GetLatLongFromAddress(string address, string apiKey)
{
try
{
_logger.Information($"A request has been made to get the latitude and longitude of the address {address} from the Google Geocode API.");
// Create a GeocodeRequest
AddressGeocodeRequest a = new AddressGeocodeRequest
{
Address = address,
Key = apiKey
};
// POST request to Google Maps API
GeocodeResponse r = await GoogleMaps.AddressGeocode.QueryAsync(a);
// Response contains a Geometry class
Geometry result = r.Results.ToList()[0].Geometry;
// Geometry contains a Location class consisting of a latitude and longitude
return(result != null && result.Location != null
? new LatLng(result.Location.Latitude, result.Location.Longitude)
: throw new ArgumentNullException($"Dependency failure: Google Geocode API request returned null for address {address}."));
}
catch (Exception e) // Error handling
{
_logger.Error($"ILocationsService says: {e.Message} Exception occured on line {new StackTrace(e, true).GetFrame(0).GetFileLineNumber()}.");
return(null);
}
}
public void AddressGeocodeWhenAddressIsNullTest()
{
var request = new AddressGeocodeRequest();
var exception = Assert.Throws <ArgumentException>(() => GoogleMaps.AddressGeocode.Query(request));
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "Address is required.");
}
public GymLocationService(IOptions <AppSettings> appSettings)
{
var appSettings1 = appSettings.Value;
_addressGeocodeRequest = new AddressGeocodeRequest {
Key = appSettings1.GoogleApiKey
};
}
public void GetQueryStringParametersTest()
{
var request = new AddressGeocodeRequest
{
Key = "abc",
Address = "abc"
};
Assert.DoesNotThrow(() => request.GetQueryStringParameters());
}
public void GetQueryStringParametersWhenKeyIsEmptyTest()
{
var request = new AddressGeocodeRequest
{
Key = string.Empty
};
var exception = Assert.Throws <ArgumentException>(() => request.GetQueryStringParameters());
Assert.AreEqual("'Key' is required", exception.Message);
}
public void AddressGeocodeWhenAsyncTest()
{
var request = new AddressGeocodeRequest
{
Address = "285 Bedford Ave, Brooklyn, NY 11211, USA"
};
var result = GoogleMaps.AddressGeocode.QueryAsync(request).Result;
Assert.IsNotNull(result);
Assert.AreEqual(Status.Ok, result.Status);
}
public void AddressGeocodeTest()
{
var request = new AddressGeocodeRequest
{
Key = this.ApiKey,
Address = "285 Bedford Ave, Brooklyn, NY 11211, USA"
};
var result = GoogleMaps.AddressGeocode.Query(request);
Assert.IsNotNull(result);
Assert.AreEqual(Status.Ok, result.Status);
}
public void GetUriTest()
{
var request = new AddressGeocodeRequest
{
Key = "abc",
Address = "abc"
};
var uri = request.GetUri();
Assert.IsNotNull(uri);
Assert.AreEqual($"/maps/api/geocode/json?key={request.Key}&language={request.Language.ToCode()}&address={Uri.EscapeDataString(request.Address)}", uri.PathAndQuery);
}
public void AddressGeocodeWhenBoundsTest()
{
var request = new AddressGeocodeRequest
{
Key = this.ApiKey,
Address = "285 Bedford Ave, Brooklyn, NY 11211, USA",
Bounds = new ViewPort(new Coordinate(40.7141289, -73.9614074), new Coordinate(40.7141289, -73.9614074))
};
var result = GoogleMaps.AddressGeocode.Query(request);
Assert.IsNotNull(result);
Assert.AreEqual(Status.Ok, result.Status);
}
public void AddressGeocodeWhenAddressIsNullTest()
{
var request = new AddressGeocodeRequest();
var exception = Assert.Throws <AggregateException>(() => GoogleMaps.AddressGeocode.QueryAsync(request).Wait());
Assert.IsNotNull(exception);
var innerException = exception.InnerException;
Assert.IsNotNull(innerException);
Assert.AreEqual(typeof(GoogleApiException), innerException.GetType());
Assert.AreEqual(innerException.Message, "Address is required");
}
public void AddressGeocodeWhenComponentsTest()
{
var request = new AddressGeocodeRequest
{
Key = this.ApiKey,
Components = new[]
{
new KeyValuePair <Component, string>(Component.Country, "dk")
}
};
var result = GoogleMaps.AddressGeocode.Query(request);
Assert.IsNotNull(result);
Assert.AreEqual(Status.Ok, result.Status);
}
public void GetQueryStringParametersWhenAddressIsNullTest()
{
var request = new AddressGeocodeRequest
{
Key = "abc"
};
var exception = Assert.Throws <ArgumentException>(() =>
{
var parameters = request.GetQueryStringParameters();
Assert.IsNull(parameters);
});
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "Address is required");
}
public void AddressGeocodeWhenAsyncAndCancelledTest()
{
var request = new AddressGeocodeRequest
{
Address = "285 Bedford Ave, Brooklyn, NY 11211, USA"
};
var cancellationTokenSource = new CancellationTokenSource();
var task = GoogleMaps.AddressGeocode.QueryAsync(request, cancellationTokenSource.Token);
cancellationTokenSource.Cancel();
var exception = Assert.Throws <OperationCanceledException>(() => task.Wait(cancellationTokenSource.Token));
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "The operation was canceled.");
}
public void GetQueryStringParametersWhenAddressIsNullAndComponentsIsEmptyTest()
{
var request = new AddressGeocodeRequest
{
Key = "key"
};
var exception = Assert.Throws <ArgumentException>(() =>
{
var parameters = request.GetQueryStringParameters();
Assert.IsNull(parameters);
});
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "'Address' or 'Components' is required");
}
public void GetUriWhenComponentsTest()
{
var request = new AddressGeocodeRequest
{
Key = "abc",
Components = new []
{
new KeyValuePair <Component, string>(Component.Administrative_Area, "abc"),
new KeyValuePair <Component, string>(Component.Locality, "def")
}
};
var uri = request.GetUri();
Assert.IsNotNull(uri);
Assert.AreEqual($"/maps/api/geocode/json?key={request.Key}&language={request.Language.ToCode()}&components={Uri.EscapeDataString(string.Join("|", request.Components.Select(x => $"{x.Key.ToString().ToLower()}:{x.Value}")))}", uri.PathAndQuery);
}
public async Task <ICollection <AddressEM> > Geocode(string request, int maxResultCount = 5)
{
var result = new List <AddressEM>();
var clientRequest = new AddressGeocodeRequest {
Address = request, Language = Language.Russian, Key = GoogleConfig.ApiKey
};
var clientResponse = await GoogleMaps.AddressGeocode.QueryAsync(clientRequest);
foreach (var geocodeResult in clientResponse.Results)
{
var address = CreateAddressByAddressComponents(geocodeResult);
result.Add(address);
}
return(result);
}
public void AddressGeocodeWhenRegionTest()
{
var request = new AddressGeocodeRequest
{
Address = "285 Bedford Ave, Brooklyn, NY 11211, USA",
Region = "Bedford"
};
var result = GoogleMaps.AddressGeocode.QueryAsync(request).Result;
Assert.IsNotNull(result);
Assert.AreEqual(Status.Ok, result.Status);
var geocodeResult = result.Results.FirstOrDefault();
Assert.IsNotNull(geocodeResult);
Assert.AreEqual(40.7140415, geocodeResult.Geometry.Location.Latitude, 0.001);
Assert.AreEqual(-73.9613119, geocodeResult.Geometry.Location.Longitude, 0.001);
}
public void GetUriWhenBoundsTest()
{
var request = new AddressGeocodeRequest
{
Key = "abc",
Address = "abc",
Bounds = new ViewPort
{
SouthWest = new Entities.Common.Location(1, 1),
NorthEast = new Entities.Common.Location(1, 1)
}
};
var uri = request.GetUri();
Assert.IsNotNull(uri);
Assert.AreEqual($"/maps/api/geocode/json?key={request.Key}&language={request.Language.ToCode()}&address={Uri.EscapeDataString(request.Address)}&bounds={Uri.EscapeDataString(request.Bounds.NorthEast.ToString())}{Uri.EscapeDataString("|")}{Uri.EscapeDataString(request.Bounds.SouthWest.ToString())}", uri.PathAndQuery);
}
public void GetQueryStringParametersWhenChannelTest()
{
var request = new AddressGeocodeRequest
{
Key = "key",
Address = "address",
Channel = "channel"
};
var queryStringParameters = request.GetQueryStringParameters();
Assert.IsNotNull(queryStringParameters);
var channel = queryStringParameters.FirstOrDefault(x => x.Key == "channel");
var channelExpected = request.Channel;
Assert.IsNotNull(channel);
Assert.AreEqual(channelExpected, channel.Value);
}
public void GetQueryStringParametersWhenBoundsTest()
{
var request = new AddressGeocodeRequest
{
Key = "key",
Address = "address",
Bounds = new ViewPort(new Coordinate(1, 1), new Coordinate(2, 2))
};
var queryStringParameters = request.GetQueryStringParameters();
Assert.IsNotNull(queryStringParameters);
var bounds = queryStringParameters.SingleOrDefault(x => x.Key == "bounds");
var boundsExpected = request.Bounds.ToString();
Assert.IsNotNull(bounds);
Assert.AreEqual(boundsExpected, bounds.Value);
}
public void GetQueryStringParametersWhenRegionTest()
{
var request = new AddressGeocodeRequest
{
Key = "key",
Address = "address",
Region = "region"
};
var queryStringParameters = request.GetQueryStringParameters();
Assert.IsNotNull(queryStringParameters);
var region = queryStringParameters.SingleOrDefault(x => x.Key == "region");
var regionExpected = request.Region;
Assert.IsNotNull(region);
Assert.AreEqual(regionExpected, region.Value);
}
public void AddressGeocodeWhenAsyncAndTimeoutTest()
{
var request = new AddressGeocodeRequest
{
Address = "285 Bedford Ave, Brooklyn, NY 11211, USA"
};
var exception = Assert.Throws <AggregateException>(() =>
{
var result = GoogleMaps.AddressGeocode.QueryAsync(request, TimeSpan.FromMilliseconds(1)).Result;
Assert.IsNull(result);
});
Assert.IsNotNull(exception);
Assert.AreEqual(exception.Message, "One or more errors occurred.");
var innerException = exception.InnerException;
Assert.IsNotNull(innerException);
Assert.AreEqual(innerException.GetType(), typeof(TaskCanceledException));
Assert.AreEqual(innerException.Message, "A task was canceled.");
}
public void AddressGeocodeWhenBoundsTest()
{
var request = new AddressGeocodeRequest
{
Address = "285 Bedford Ave, Brooklyn, NY 11211, USA",
Bounds = new ViewPort
{
NorthEast = new Entities.Common.Location(40.7141289, -73.9614074),
SouthWest = new Entities.Common.Location(40.7141289, -73.9614074)
}
};
var result = GoogleMaps.AddressGeocode.QueryAsync(request).Result;
Assert.IsNotNull(result);
Assert.AreEqual(Status.Ok, result.Status);
var geocodeResult = result.Results.FirstOrDefault();
Assert.IsNotNull(geocodeResult);
Assert.AreEqual(40.7140415, geocodeResult.Geometry.Location.Latitude, 0.001);
Assert.AreEqual(-73.9613119, geocodeResult.Geometry.Location.Longitude, 0.001);
}
public void GetQueryStringParametersWhenComponentsTest()
{
var request = new AddressGeocodeRequest
{
Key = "key",
Components = new[]
{
new KeyValuePair <Component, string>(Component.Administrative_Area, "component1"),
new KeyValuePair <Component, string>(Component.Locality, "component2")
}
};
var queryStringParameters = request.GetQueryStringParameters();
Assert.IsNotNull(queryStringParameters);
var components = queryStringParameters.SingleOrDefault(x => x.Key == "components");
var componentsExpected = string.Join("|", request.Components.Select(x => $"{x.Key.ToString().ToLower()}:{x.Value}"));
Assert.IsNotNull(components);
Assert.AreEqual(componentsExpected, components.Value);
}
public void AddressGeocodeTest()
{
var request = new AddressGeocodeRequest
{
Address = "285 Bedford Ave, Brooklyn, NY 11211, USA"
};
var result = GoogleMaps.AddressGeocode.Query(request);
Assert.IsNotNull(result);
Assert.AreEqual(Status.Ok, result.Status);
var geocodeResult = result.Results.FirstOrDefault();
Assert.IsNotNull(geocodeResult);
Assert.AreEqual(40.7140415, geocodeResult.Geometry.Location.Latitude, 0.001);
Assert.AreEqual(-73.9613119, geocodeResult.Geometry.Location.Longitude, 0.001);
var types = geocodeResult.Types?.ToArray();
Assert.IsNotNull(types);
Assert.IsNotEmpty(types);
Assert.Contains(PlaceLocationType.Premise, types);
}
public async Task <GeocodeResponse> GetCoordinatesAsync(string address)
{
if (string.IsNullOrEmpty(address))
{
return(new GeocodeResponse());
}
if (address.Length > 6000)
{
address = address.Substring(0, 6000);
}
var request = new AddressGeocodeRequest
{
Key = apiKey,
Address = address,
Language = Language.Russian,
};
var result = await GoogleMaps.AddressGeocode.QueryAsync(request);
return(result);
}
public void AddressGeocodeWhenBoundsAmbiguousTest()
{
var request = new AddressGeocodeRequest
{
Key = this.ApiKey,
Address = "Yellow Rock",
Bounds = new ViewPort
{
NorthEast = new Entities.Common.Location(37.771819, -111.603914),
SouthWest = new Entities.Common.Location(37.039739, -112.514545)
}
};
var result = GoogleMaps.AddressGeocode.QueryAsync(request).Result;
Assert.IsNotNull(result);
Assert.AreEqual(Status.Ok, result.Status);
var geocodeResult = result.Results.FirstOrDefault();
Assert.IsNotNull(geocodeResult);
Assert.AreEqual(37.2583855, geocodeResult.Geometry.Location.Latitude, 0.001);
Assert.AreEqual(-111.9221377, geocodeResult.Geometry.Location.Longitude, 0.001);
}
public void ConstructorDefaultTest()
{
var request = new AddressGeocodeRequest();
Assert.IsTrue(request.IsSsl);
}
public void ConstructorDefaultTest()
{
var request = new AddressGeocodeRequest();
Assert.AreEqual(Language.English, request.Language);
}
