< Summary

Information
Class: MyNet.Google.Maps.GoogleLocationService
Assembly: MyNet.Google
File(s): https://raw.githubusercontent.com/sandre58/MyNet/5aaaab311aa14541478b9e402357d98b657a23e4/src/MyNet.Google/Maps/GoogleLocationService.cs
Tag: 342_31701152804
Line coverage
85%
Covered lines: 89
Uncovered lines: 15
Coverable lines: 104
Total lines: 255
Line coverage: 85.5%
Branch coverage
64%
Covered branches: 81
Total branches: 126
Branch coverage: 64.2%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)83.33%66100%
.ctor(...)100%210%
.ctor()100%210%
get_ApiUrlRegionFromLatLong()100%11100%
get_ApiUrlLatLongFromAddress()100%11100%
get_ApiUrlDirections()100%11100%
GetRegionFromCoordinates(...)50%22100%
GetAddressFromCoordinates(...)72.72%676693.75%
GetCoordinatesFromAddress(...)62.5%1616100%
GetCoordinatesFromAddress(...)100%210%
GetAddressesListFromAddress(...)50%9871.42%
GetAddressesListFromAddress(...)100%210%
GetDirections(...)45.45%232287.87%
ResolveCountry(...)50%44100%
ParseUs(...)50%22100%
LoadXmlDocumentFromUrl(...)100%210%

File(s)

https://raw.githubusercontent.com/sandre58/MyNet/5aaaab311aa14541478b9e402357d98b657a23e4/src/MyNet.Google/Maps/GoogleLocationService.cs

#LineLine coverage
 1// -----------------------------------------------------------------------
 2// <copyright file="GoogleLocationService.cs" company="Stéphane ANDRE">
 3// Copyright (c) Stéphane ANDRE. All rights reserved.
 4// </copyright>
 5// -----------------------------------------------------------------------
 6
 7using System;
 8using System.Globalization;
 9using System.Linq;
 10using System.Xml;
 11using System.Xml.Linq;
 12using MyNet.Geography;
 13using MyNet.Primitives;
 14
 15namespace MyNet.Google.Maps;
 16
 17public class GoogleLocationService(string apikey, bool useHttps, Func<string, XDocument>? loadXDocument = null, Func<str
 18{
 2419    private readonly string _urlProtocolPrefix = useHttps ? "https://" : "http://";
 2420    private readonly Func<string, XDocument> _loadXDocument = loadXDocument ?? XDocument.Load;
 2421    private readonly Func<string, XmlDocument> _loadXmlDocument = loadXmlDocument ?? LoadXmlDocumentFromUrl;
 22
 23    /// <summary>
 24    /// Initializes a new instance of the <see cref="GoogleLocationService"/> class.
 25    /// </summary>
 26    /// <param name="useHttps">Indicates whether to call the Google API over HTTPS or not.</param>
 27    public GoogleLocationService(bool useHttps)
 028        : this(string.Empty, useHttps) { }
 29
 30    /// <summary>
 31    /// Initializes a new instance of the <see cref="GoogleLocationService"/> class. Current calling the API over regula
 32    /// HTTP (not HTTPS).
 33    /// </summary>
 34    public GoogleLocationService()
 035        : this(string.Empty, false) { }
 36
 937    private string ApiUrlRegionFromLatLong => _urlProtocolPrefix + Constants.ApiUriTemplates.ApiRegionFromLatLong;
 38
 1239    private string ApiUrlLatLongFromAddress => _urlProtocolPrefix + Constants.ApiUriTemplates.ApiLatLongFromAddress;
 40
 341    private string ApiUrlDirections => _urlProtocolPrefix + Constants.ApiUriTemplates.ApiDirections;
 42
 43    /// <summary>
 44    /// Translates a Latitude / Longitude into a Region (state) using Google Maps api.
 45    /// </summary>
 46    public Region? GetRegionFromCoordinates(double latitude, double longitude)
 47    {
 348        var doc = _loadXDocument(string.Format(CultureInfo.InvariantCulture, ApiUrlRegionFromLatLong, latitude, longitud
 49
 350        var els = doc.Descendants("result").First().Descendants("address_component").FirstOrDefault(s => s.Descendants("
 51
 352        return els != null ? new Region { Name = els.Descendants("long_name").First().Value, ShortCode = els.Descendants
 53    }
 54
 55    /// <summary>
 56    /// Translates a Latitude / Longitude into an address using Google Maps api.
 57    /// </summary>
 58    public Address? GetAddressFromCoordinates(double latitude, double longitude)
 59    {
 660        var addressCountry = string.Empty;
 661        var addressCountryCode = string.Empty;
 662        var addressLocality = string.Empty;
 663        var addressSubLocality = string.Empty;
 664        var addressRoute = string.Empty;
 665        var addressStreetNumber = string.Empty;
 666        var addressPostalCode = string.Empty;
 67
 668        var doc = _loadXmlDocument(string.Format(CultureInfo.InvariantCulture, ApiUrlRegionFromLatLong, latitude, longit
 669        var element = doc.SelectSingleNode("//GeocodeResponse/status");
 670        if (element is not { InnerText: not Constants.ApiResponses.ZeroResults })
 71        {
 372            return null;
 73        }
 74
 375        var xnList = doc.SelectNodes("//GeocodeResponse/result/address_component");
 76
 377        if (xnList == null) return null;
 78
 3679        foreach (XmlNode? xn in xnList)
 80        {
 1581            var longName = xn?["long_name"]?.InnerText;
 1582            var shortname = xn?["short_name"]?.InnerText;
 1583            var typename = xn?["type"]?.InnerText;
 84
 85            switch (typename)
 86            {
 87                case "country":
 388                    addressCountry = longName;
 389                    addressCountryCode = shortname;
 390                    break;
 91                case "locality":
 392                    addressLocality = longName;
 393                    break;
 94                case "sublocality":
 095                    addressSubLocality = longName;
 096                    break;
 97                case "neighborhood":
 98                case "colloquial_area":
 99                case "administrative_area_level_1":
 100                case "administrative_area_level_2":
 101                case "administrative_area_level_3":
 102                    break;
 103                case "route":
 3104                    addressRoute = shortname;
 3105                    break;
 106                case "street_number":
 3107                    addressStreetNumber = shortname;
 3108                    break;
 109                case "postal_code":
 3110                    addressPostalCode = longName;
 111                    break;
 112            }
 113        }
 114
 3115        var country = ResolveCountry(addressCountry, addressCountryCode);
 3116        var streetParts = new[] { addressStreetNumber, addressRoute, addressSubLocality }.Where(static x => x is not nul
 3117        return new Address(string.Join(" ", streetParts), addressPostalCode, addressLocality, country, new Coordinates(l
 118    }
 119
 120    /// <summary>
 121    /// Gets the latitude and longitude that belongs to an address.
 122    /// </summary>
 123    /// <param name="address">The address.</param>
 124    public Coordinates? GetCoordinatesFromAddress(string address)
 125    {
 9126        var doc = _loadXDocument(string.Format(CultureInfo.InvariantCulture, ApiUrlLatLongFromAddress, Uri.EscapeDataStr
 127
 9128        var status = doc.Descendants("status").FirstOrDefault()?.Value;
 129        switch (status)
 130        {
 131            case Constants.ApiResponses.OverQueryLimit:
 3132                throw new QueryLimitExceededException("QueryLimit exceeded, check your dashboard");
 133            case Constants.ApiResponses.RequestDenied:
 3134                throw new RequestDeniedException("Request denied, it's likely you need to enable the necessary Google ma
 135        }
 136
 3137        var els = doc.Descendants("result").Descendants("geometry").Descendants("location").FirstOrDefault();
 3138        if (els == null) return null;
 3139        var latitude = ParseUs((els.Nodes().First() as XElement)?.Value);
 3140        var longitude = ParseUs((els.Nodes().ElementAt(1) as XElement)?.Value);
 3141        return latitude.HasValue && longitude.HasValue ? new Coordinates(latitude.Value, longitude.Value) : null;
 142    }
 143
 144    /// <summary>
 145    /// Gets the latitude and longitude that belongs to an address.
 146    /// </summary>
 147    /// <param name="address">The address.</param>
 0148    public Coordinates? GetCoordinatesFromAddress(Address address) => GetCoordinatesFromAddress(address.ToString());
 149
 150    /// <summary>
 151    /// Gets an array of string addresses that matched a possibly ambiguous address.
 152    /// </summary>
 153    /// <param name="address">The address.</param>
 154    public string[] GetAddressesListFromAddress(string address)
 155    {
 3156        var doc = _loadXDocument(string.Format(CultureInfo.InvariantCulture, ApiUrlLatLongFromAddress, Uri.EscapeDataStr
 3157        var status = doc.Descendants("status").FirstOrDefault()?.Value;
 158
 159        switch (status)
 160        {
 161            case Constants.ApiResponses.OverQueryLimit:
 0162                throw new QueryLimitExceededException("QueryLimit exceeded, check your dashboard");
 163            case Constants.ApiResponses.RequestDenied:
 0164                throw new RequestDeniedException("Request denied, it's likely you need to enable the necessary Google ma
 165        }
 166
 3167        var results = doc.Descendants("result").Descendants("formatted_address").ToArray();
 3168        var addresses = (from elem in results select elem.Value).ToArray();
 3169        return addresses.Length > 0 ? addresses : [];
 170    }
 171
 172    /// <summary>
 173    /// Gets an array of string addresses that matched a possibly ambiguous address.
 174    /// </summary>
 175    /// <param name="address">The address.</param>
 0176    public string[] GetAddressesListFromAddress(Address address) => GetAddressesListFromAddress(address.ToString());
 177
 178    /// <summary>
 179    /// Gets the directions.
 180    /// </summary>
 181    /// <param name="fromAddress">From address.</param>
 182    /// <param name="toAddress">To address.</param>
 183    /// <returns>The directions.</returns>
 184    public Directions GetDirections(Address fromAddress, Address toAddress)
 185    {
 3186        var direction = new Directions();
 187
 3188        var doc = _loadXDocument(string.Format(CultureInfo.InvariantCulture,
 3189            ApiUrlDirections,
 3190            Uri.EscapeDataString(fromAddress.ToString()),
 3191            Uri.EscapeDataString(toAddress.ToString())) + "&key=" + apikey);
 192
 3193        var status = (from s in doc.Descendants("DirectionsResponse").Descendants("status")
 3194                      select s).FirstOrDefault();
 195
 3196        if (status is { Value: "OK" })
 197        {
 3198            direction.StatusCode = Directions.Status.Ok;
 3199            var distance = (from d in doc.Descendants("DirectionsResponse").Descendants("route").Descendants("leg")
 3200                    .Descendants("distance").Descendants("text")
 3201                            select d).LastOrDefault();
 202
 3203            if (distance != null)
 204            {
 3205                direction.Distance = distance.Value;
 206            }
 207
 3208            var duration = (from d in doc.Descendants("DirectionsResponse").Descendants("route").Descendants("leg")
 3209                    .Descendants("duration").Descendants("text")
 3210                            select d).LastOrDefault();
 211
 3212            if (duration != null)
 213            {
 3214                direction.Duration = duration.Value;
 215            }
 216
 3217            var steps = from s in doc.Descendants("DirectionsResponse").Descendants("route").Descendants("leg").Descenda
 3218                        select s;
 219
 12220            foreach (var step in steps)
 221            {
 3222                var directionStep = new Step
 3223                {
 3224                    Instruction = step?.Element("html_instructions")?.Value,
 3225                    Distance = step?.Descendants("distance").First().Element("text")?.Value
 3226                };
 3227                direction.Steps.Add(directionStep);
 228            }
 229
 3230            return direction;
 231        }
 232
 0233        if (status is not { Value: not "OK" })
 0234            throw new InvalidOperationException("Unable to get Directions from Google");
 0235        direction.StatusCode = Directions.Status.Failed;
 0236        return direction;
 237    }
 238
 3239    private static Country? ResolveCountry(string? countryName, string? countryCode) => Country.TryFromValue(countryName
 3240        ? byName
 3241        : string.IsNullOrEmpty(countryCode)
 3242            ? null
 3243            : Country.All.FirstOrDefault(c =>
 3244                string.Equals(c.Alpha2, countryCode, StringComparison.OrdinalIgnoreCase));
 245
 6246    private static double? ParseUs(string? value) => value is null ? null : double.Parse(value, new CultureInfo("en-US")
 247
 248    private static XmlDocument LoadXmlDocumentFromUrl(string url)
 249    {
 0250        var doc = new XmlDocument();
 0251        doc.Load(url);
 0252        return doc;
 253    }
 254}
 255