/// <summary>
/// Checks if city, state, and country match address
/// </summary>
/// <param name="stop"></param>
/// <param name="address"></param>
/// <returns></returns>
private bool DoesAddressMatchResult(LoadStopData stop, GeocodeAddress address)
{
var isValid = false;
if (address != null)
{
if (address.City != null && address.State != null && address.Country != null)
{
stop.Country = ConvertCountry(stop.Country);
isValid =
ConvertStringForComparison(address.City).Equals(ConvertStringForComparison(stop.City),
StringComparison.OrdinalIgnoreCase) &&
ConvertStringForComparison(address.State).Equals(ConvertStringForComparison(stop.State),
StringComparison.OrdinalIgnoreCase) &&
ConvertStringForComparison(address.Country).Equals(ConvertStringForComparison(stop.Country),
StringComparison.OrdinalIgnoreCase);
}
if (isValid && !string.IsNullOrWhiteSpace(stop.Address1))
{
isValid = ConvertStringForComparison(address.Address1)
.Equals(ConvertStringForComparison(stop.Address1), StringComparison.OrdinalIgnoreCase);
}
if (isValid && !string.IsNullOrWhiteSpace(stop.PostalCode))
{
isValid = ConvertStringForComparison(address.PostalCode)
.Equals(ConvertStringForComparison(stop.PostalCode), StringComparison.OrdinalIgnoreCase);
}
}
return(isValid);
}
public GeocodeAddress RequestGeocodeAddress(String address)
{
//�����������geocoder��
String urlString = "http://geocoder.us/service/rest/geocode?address=" + HttpUtility.UrlEncode(address);
HttpWebRequest getRequest = (HttpWebRequest)WebRequest.Create(urlString);
getRequest.Method = "GET";
WebResponse response = null;
response = getRequest.GetResponse();
Stream responseStream = response.GetResponseStream();
GeocodeAddress addr = new GeocodeAddress();
XmlDocument doc = new XmlDocument();
doc.Load(responseStream);
addr.lon = doc.GetElementsByTagName("geo:long").Item(0).FirstChild.Value;
addr.lat = doc.GetElementsByTagName("geo:lat").Item(0).FirstChild.Value;
address = doc.GetElementsByTagName("dc:description").Item(0).FirstChild.Value;
int sep = address.IndexOf(',');
if (sep != -1)
{
addr.address1 = address.Substring(0, sep);
addr.address2 = address.Substring(sep + 1);
}
else
{
addr.address1 = address;
}
return addr;
}
public async Task Should_return_candidate_from_poboxes()
{
const int pobox = -1;
const int zip = 84114;
var parsedAddress = new CleansedAddress("inputAddress", 1, 0, pobox, Direction.North, "street",
StreetType.Alley, Direction.South, 0, zip, false, false);
var address = new GeocodeAddress(parsedAddress)
{
AddressGrids = new[] { new ZipGridLink(84114, "grid", 0) }
};
var geocodeOptions = new GeocodingOptions {
PoBox = true,
SpatialReference = 26912
};
var request = new PoBoxLocation.Command(address, geocodeOptions);
var result = await _handler.Handle(request, new CancellationToken());
result.Score.ShouldBe(100);
result.Locator.ShouldBe("Post Office Point");
result.Location.X.ShouldBe(1);
result.Location.Y.ShouldBe(1);
result.AddressGrid.ShouldBe("grid");
}
public async Task Should_create_extra_for_address_reversal()
{
var parsedAddress = new CleansedAddress("inputAddress", 1, 0, 0, Direction.North, "2", StreetType.Alley,
Direction.South, 0, 84114, false, false);
var address = new GeocodeAddress(parsedAddress)
{
AddressGrids = new[] { new PlaceGridLink("place", "grid", 0) }
};
var geocodeOptions = new GeocodingOptions {
Locators = LocatorType.RoadCenterlines,
SpatialReference = 26912
};
var request = new LocatorsForGeocode.Command(address, geocodeOptions);
var result = await Handler.Handle(request, new CancellationToken());
result.Count.ShouldBe(2);
result.Count(x => x.Url ==
"proto://test:1/arcgis/rest/services/Geolocators/Roads_AddressSystem_STREET/GeocodeServer/findAddressCandidates?f=json&Street=1+North+2+Alley+South&City=grid&outSR=26912")
.ShouldBe(1);
result.Count(x => x.Url ==
"proto://test:1/arcgis/rest/services/Geolocators/Roads_AddressSystem_STREET/GeocodeServer/findAddressCandidates?f=json&Street=2+South+Alley+1+North&City=grid&outSR=26912")
.ShouldBe(1);
}
public async Task Should_return_all_geocoders()
{
var parsedAddress = new CleansedAddress("inputAddress", 1, 0, 0, Direction.North, "street",
StreetType.Alley, Direction.South, 0, 84114, false, false);
var address = new GeocodeAddress(parsedAddress)
{
AddressGrids = new[] { new PlaceGridLink("place", "grid", 0) }
};
var geocodeOptions = new GeocodingOptions {
Locators = LocatorType.All,
SpatialReference = 26912
};
var request = new LocatorsForGeocode.Command(address, geocodeOptions);
var result = await Handler.Handle(request, new CancellationToken());
result.Count.ShouldBe(2);
geocodeOptions = new GeocodingOptions {
Locators = LocatorType.Default,
SpatialReference = 26912
};
request = new LocatorsForGeocode.Command(address, geocodeOptions);
result = await Handler.Handle(request, new CancellationToken());
result.Count.ShouldBe(2);
}
public async Task Should_remove_candidates_below_accept_score()
{
var candidates = new[] {
new Candidate {
Address = "winner",
Score = 1,
AddressGrid = "grid",
Location = new Point(0, 0)
},
new Candidate {
Address = "remove",
Score = 0,
AddressGrid = "grid",
Location = new Point(1, 1)
}
};
var options = new GeocodingOptions {
AcceptScore = 1,
Suggest = 1
};
var address = new GeocodeAddress(new CleansedAddress())
{
AddressGrids = new[] { new ZipGridLink(0, "grid", 0) }
};
var request = new FilterCandidates.Command(candidates, options, "street", "zone", address);
var result = await Handler.Handle(request, CancellationToken.None);
result.Candidates.ShouldBeEmpty();
result.MatchAddress.ShouldBe("winner");
}
public void ScoreDifferenceCalculatedWhenSuggestFalse()
{
// these are sorted out of the TopNList by the CandidateComparer
var candidates = new List <Candidate>
{
new Candidate
{
Address = "top match",
Score = 100,
Weight = 0,
AddressGrid = "Grid",
Location = new Location(0, 0)
},
new Candidate
{
Address = "top suggestion",
Score = 90.87,
Weight = 0,
AddressGrid = "Grid"
},
new Candidate
{
Address = "suggestion",
Score = 80.87,
Weight = 0,
AddressGrid = "Grid"
},
new Candidate
{
Address = "another suggestion",
Score = 70.87,
Weight = 0,
AddressGrid = "Grid"
}
};
var options = new GeocodeOptions
{
ScoreDifference = true
};
var address = new GeocodeAddress(new CleansedAddress("", 0, 0, 0, Direction.None, "", StreetType.None, Direction.None, 0, 0, false, false))
{
AddressGrids = new List <GridLinkable>
{
new PlaceGridLink("City", "Grid", 0)
}
};
var command = new ChooseBestAddressCandidateCommand(candidates,
options,
"top match",
"test",
address);
command.Run();
var match = command.Result;
Assert.That(Math.Round(match.ScoreDifference), Is.EqualTo(Math.Round(100 - 90.87)));
}
public async Task Should_calculate_score_difference()
{
var candidates = new[] {
new Candidate {
Address = "winner",
Score = 10,
AddressGrid = "grid",
Location = new Point(0, 0)
},
new Candidate {
Address = "suggest",
Score = 1,
AddressGrid = "grid",
Location = new Point(1, 1)
}
};
var options = new GeocodingOptions {
AcceptScore = 1,
ScoreDifference = true
};
var address = new GeocodeAddress(new CleansedAddress())
{
AddressGrids = new[] { new ZipGridLink(0, "grid", 0) }
};
var request = new FilterCandidates.Command(candidates, options, "street", "zone", address);
var result = await Handler.Handle(request, CancellationToken.None);
result.Candidates.ShouldBeEmpty();
result.ScoreDifference.ShouldBe(9);
}
public void Initialize(GeocodeAddress address, GeocodingOptions options)
{
Address = address;
Options = options;
BuildAddressPermutations();
BuildLocatorLookup();
}
public async Task Should_return_empty_grid_if_zone_not_found()
{
var address = new GeocodeAddress(new CleansedAddress());
var request = new ZoneParsing.Command("123eastbumble", address);
var result = await _handler.Handle(request, new CancellationToken());
result.AddressGrids.ShouldBeEmpty();
}
public GetAltNameLocatorsForAddressCommand(GeocodeAddress address, GeocodeOptions options)
{
Host = ConfigurationManager.AppSettings["gis_server_host"];
Address = address;
Options = options;
BuildAddressPermutations();
BuildLocatorLookup();
}
public async Task Should_parse_zip_parts(string input)
{
var address = new GeocodeAddress(new CleansedAddress());
var request = new ZoneParsing.Command(input, address);
var result = await _handler.Handle(request, new CancellationToken());
result.Zip5.ShouldBe(12345);
result.Zip4.ShouldBe(6789);
}
public async Task Should_find_grid_from_place(string input)
{
var address = new GeocodeAddress(new CleansedAddress());
var request = new ZoneParsing.Command(input, address);
var result = await _handler.Handle(request, new CancellationToken());
result.AddressGrids.ShouldHaveSingleItem();
result.AddressGrids.First().Grid.ShouldBe("grid");
}
public void MidvaleAvenuesAddsWestIfNotSuppliedForCity(string streetname, string city, Direction direction)
{
var address = new GeocodeAddress(new CleansedAddress("", 0, 0, 0, Direction.None, streetname,
StreetType.Avenue, Direction.None, 0, null, false, false));
var command = new DoubleAvenuesExceptionCommand(address, city);
command.Run();
Assert.That(command.GetResult().PrefixDirection, Is.EqualTo(direction));
}
public GeocodeInput(GeocodeAddress addressInfo, string grid, int weight, LocatorProperties locator,
int wkId = 26912)
{
var street = addressInfo.StandardizedAddress;
AddressInfo = addressInfo;
Address = street;
Grid = grid;
Weight = weight;
Locator = locator;
WkId = wkId;
}
public async Task Should_add_east_to_slc_avenue_if_not_supplied_for_city(
string streetname, string city, Direction direction)
{
var address = new GeocodeAddress(new CleansedAddress("", 0, 0, 0, Direction.None, streetname,
StreetType.Avenue, Direction.None, 0, null, false,
false));
var request = new ZoneParsing.Command(city, address);
var result = await _handler.Handle(request, new CancellationToken(),
() => _requestHandler.Handle(request, CancellationToken.None));
result.PrefixDirection.ShouldBe(direction);
}
public void EmptyStrings_NullValues()
{
var expected = new GeocodeAddress(item: null);
var stop = new LoadStopData
{
Address1 = string.Empty,
City = string.Empty,
State = string.Empty,
Country = string.Empty,
PostalCode = string.Empty
};
var actual = _svc.GetValidAddress(stop);
actual.Should().BeEquivalentTo(expected);
}
public async Task Should_return_null_for_address_without_zip_code()
{
var parsedAddress = new CleansedAddress("inputAddress", 1, 0, 0, Direction.North, "street",
StreetType.Alley, Direction.South, 0, new int?(), false, false);
var address = new GeocodeAddress(parsedAddress);
var geocodeOptions = new GeocodingOptions {
PoBox = true
};
var request = new PoBoxLocation.Command(address, geocodeOptions);
var result = await _handler.Handle(request, new CancellationToken());
result.ShouldBeNull();
}
public void ScoreDifferenceDoesNotCalculatedWhenSuggestIsGreatherThanZero()
{
var candidates = new List <Candidate>
{
new Candidate
{
Address = "top match",
Score = 100,
Weight = 0,
AddressGrid = "Grid",
Location = new Location(0, 0)
},
new Candidate
{
Address = "top suggestion",
Score = 90.87,
Weight = 0,
AddressGrid = "Grid"
}
};
var options = new GeocodeOptions
{
SuggestCount = 1
};
var address = new GeocodeAddress(new CleansedAddress("", 0, 0, 0, Direction.None, "", StreetType.None, Direction.None, 0, 0, false, false))
{
AddressGrids = new List <GridLinkable>
{
new PlaceGridLink("City", "Grid", 0)
}
};
var command = new ChooseBestAddressCandidateCommand(candidates,
options,
"top match",
"test",
address);
command.Run();
var match = command.Result;
Assert.That(match.Score, Is.EqualTo(100));
Assert.That(match.Candidates.Length, Is.EqualTo(1));
Assert.That(match.ScoreDifference, Is.EqualTo(-1));
}
private static IReadOnlyCollection <GeocodeInput> BuildAddressPermutations(
GeocodeAddress address, int spatialReference)
{
var addressPermutations = new List <GeocodeInput>();
if (!address.AddressGrids.Any())
{
return(Array.Empty <GeocodeInput>());
}
foreach (var grid in address.AddressGrids)
{
addressPermutations.Add(new GeocodeInput(address, grid.Grid, grid.Weight, null, spatialReference));
}
return(addressPermutations);
}
private Dictionary <LocatorType, IReadOnlyCollection <LocatorProperties> > BuildLocatorLookup(
GeocodeAddress address, IReadOnlyCollection <GeocodeInput> permutations)
{
var locatorLookup = new Dictionary <LocatorType, IReadOnlyCollection <LocatorProperties> >();
_log.Verbose("Finding locators for {address}", address);
Add(Intersection(), ref locatorLookup, LocatorType.All);
Add(AddressPoints(permutations), ref locatorLookup, LocatorType.AddressPoints);
Add(Reversal(address.IsReversal(), address.PossibleReversal(), permutations), ref locatorLookup,
LocatorType.RoadCenterlines);
Add(Centerlines(address.IsReversal(), permutations), ref locatorLookup, LocatorType.RoadCenterlines);
_log.Debug("Using {locators} for {address}", locatorLookup, address);
return(locatorLookup);
}
public void GetAddressComponent()
{
var addressComponents = new List <AddressComponent>()
{
new AddressComponent()
{
ShortName = "city",
Types = new List <string>()
{
"locality",
"political"
}
},
new AddressComponent()
{
ShortName = "state",
Types = new List <string>()
{
"administrative_area_level_1",
"political"
}
}
};
var types = new List <string>()
{
"locality",
"political"
};
var result = GeocodeAddress.GetAddressComponent(addressComponents, types);
result.Should().NotBeNull();
result.ShortName.Should().Be("city");
types = new List <string>()
{
"political",
"administrative_area_level_1"
};
result = GeocodeAddress.GetAddressComponent(addressComponents, types);
result.Should().NotBeNull();
result.ShortName.Should().Be("state");
}
public async Task Should_return_empty_when_no_grids()
{
var parsedAddress = new CleansedAddress("inputAddress", 1, 0, 0, Direction.North, "street",
StreetType.Alley, Direction.South, 0, 84114, false, false);
var address = new GeocodeAddress(parsedAddress)
{
AddressGrids = Array.Empty <GridLinkable>()
};
var geocodeOptions = new GeocodingOptions {
Locators = LocatorType.RoadCenterlines,
SpatialReference = 26912
};
var request = new LocatorsForGeocode.Command(address, geocodeOptions);
var result = await Handler.Handle(request, new CancellationToken());
result.ShouldBeEmpty();
}
public void IgnoresNoGrid()
{
var candidates = new List <Candidate>
{
new Candidate
{
Address = "top match",
Score = 100,
Weight = 0,
Location = new Location(0, 0)
},
new Candidate
{
Address = "top suggestion",
Score = 90.87,
Weight = 0,
AddressGrid = "GRID",
Location = new Location(0, 0)
}
};
var options = new GeocodeOptions();
var address = new GeocodeAddress(new CleansedAddress("", 0, 0, 0, Direction.None, "", StreetType.None, Direction.None, 0, 0, false, false))
{
AddressGrids = new List <GridLinkable>
{
new PlaceGridLink("City", "GrId", 0)
}
};
var command = new ChooseBestAddressCandidateCommand(candidates,
options,
"top match",
"test",
address);
command.Run();
var match = command.Result;
Assert.That(match.Score, Is.EqualTo(90.87));
}
public Command(IList <Candidate> candidates, GeocodingOptions geocodeOptions,
string street, string zone, GeocodeAddress geocodedAddress)
{
GeocodeOptions = geocodeOptions;
Street = street;
Zone = zone;
GeocodedAddress = geocodedAddress;
if (candidates == null)
{
candidates = Array.Empty <Candidate>();
}
foreach (var candidate in candidates)
{
candidate.ScoreDifference = -1;
}
Candidates = candidates;
}
//----------------------------------------------------------------------------------------
// �� �ܣ� ��ѯָ����Χ�ڵ�Ҫ��
//
// �� �ߣ�
//
//
// �� �ڣ�2007.05.#
//
//-----------------------------------------------------------------------------------------
public ParcelProperty[] GetNearParcels(string parcelType, GeocodeAddress geocodeAddress, double bufferDistance)
{
ParcelProperty[] parcelProperties = null;
//���ڵ�ַ���� ���ε�͵�Ļ������������Σ�
MgGeometryFactory geoFactory = new MgGeometryFactory();
MgCoordinate coord = geoFactory.CreateCoordinateXY(Convert.ToDouble(geocodeAddress.lon), Convert.ToDouble(geocodeAddress.lat));
MgPoint pt = geoFactory.CreatePoint(coord);
//��ѯ��ָ����Χ�ڣ�����Σ���Ҫ��
MgPolygon buffer = (MgPolygon)pt.Buffer(bufferDistance, null);
MgFeatureService featureService = (MgFeatureService)siteConnection.CreateService(MgServiceType.FeatureService);
MgFeatureQueryOptions query = new MgFeatureQueryOptions();
query.SetFilter("RTYPE LIKE '" + parcelType + "%'");
query.SetSpatialFilter("SHPGEOM", buffer, MgFeatureSpatialOperations.Inside);
MgResourceIdentifier resId = new MgResourceIdentifier("Library://Samples/Sheboygan/Data/Parcels.FeatureSource");
MgFeatureReader featReader = featureService.SelectFeatures(resId, "Parcels", query);
//�����ѯ���
ArrayList props = new ArrayList();
while (featReader.ReadNext())
{
ParcelProperty prop = new ParcelProperty();
prop.ID = featReader.GetInt32("Autogenerated_SDF_ID").ToString();
prop.Acreage = featReader.GetString("RACRE");
prop.BillingAddr = featReader.GetString("RBILAD");
prop.Description1 = featReader.GetString("RLDESCR1");
prop.Description2 = featReader.GetString("RLDESCR2");
prop.Description3 = featReader.GetString("RLDESCR3");
prop.Description4 = featReader.GetString("RLDESCR4");
prop.LotDimension = featReader.GetString("RLOT");
prop.LotSize = featReader.GetInt32("RSQFT");
prop.Owner = featReader.GetString("RNAME");
prop.Zoning = featReader.GetString("RTYPE");
props.Add(prop);
}
parcelProperties = (ParcelProperty[])props.ToArray(typeof(ParcelProperty));
return parcelProperties;
}
public GeocodeAddress GetValidAddress(LoadStopData stop)
{
var response = GetGeocodeResponse(stop);
if (response?.Results != null)
{
foreach (var item in response.Results)
{
if (item?.AddressComponents != null)
{
var address = new GeocodeAddress(item);
if (DoesAddressMatchResult(stop, address))
{
return(address);
}
}
}
}
return(new GeocodeAddress(response?.Results?.FirstOrDefault()));
}
public void ValidAddress_MatchingGeocodeAddress(string streetNumber, string route, string city, string stateName, string stateAbbrev, string countryName, string countryCode, string postalCode)
{
MockHttpResponse(streetNumber, route, city, "", stateName, stateAbbrev, countryName, countryCode, postalCode);
var stop = new LoadStopData
{
Address1 = $"{streetNumber} {route}".Trim(),
City = city,
State = stateAbbrev,
Country = countryCode,
PostalCode = postalCode
};
var expected = new GeocodeAddress(stop)
{
StreetNumber = streetNumber ?? string.Empty,
Route = route ?? string.Empty
};
var actual = _svc.GetValidAddress(stop);
actual.Should().BeEquivalentTo(expected);
}
public ChooseBestAddressCandidateCommand(IEnumerable <Candidate> candidates, GeocodeOptions geocodeOptions,
string street, string zone, GeocodeAddress geocodedAddress)
{
GeocodeOptions = geocodeOptions;
Street = street;
Zone = zone;
GeocodedAddress = geocodedAddress;
if (candidates == null)
{
candidates = new List <Candidate>();
}
var enumerable = candidates as IList <Candidate> ?? candidates.ToList();
foreach (var candidate in enumerable)
{
candidate.ScoreDifference = -1;
}
Candidates = enumerable.ToList();
}
/// <summary>
/// Checks if a response is valid
/// </summary>
/// <param name="stop"></param>
/// <param name="response"></param>
/// <returns></returns>
private bool IsValid(LoadStopData stop, GeocodeResponse response)
{
var result = false;
if (response?.Results != null)
{
foreach (var item in response.Results)
{
if (item?.AddressComponents != null)
{
var address = new GeocodeAddress(item);
result = DoesAddressMatchResult(stop, address);
if (result)
{
break;
}
}
}
}
return(result);
}
public void ScoreDifferenceCalculatedWhenSuggestFalseAndNoSuggestions()
{
var candidates = new List <Candidate>
{
new Candidate
{
Address = "top match",
Score = 100,
Weight = 0,
AddressGrid = "Grid",
Location = new Location(0, 0)
}
};
var options = new GeocodeOptions
{
ScoreDifference = true
};
var address = new GeocodeAddress(new CleansedAddress("", 0, 0, 0, Direction.None, "", StreetType.None, Direction.None, 0, 0, false, false))
{
AddressGrids = new List <GridLinkable>
{
new PlaceGridLink("City", "Grid", 0)
}
};
var command = new ChooseBestAddressCandidateCommand(candidates,
options,
"top match",
"test",
address);
command.Run();
var match = command.Result;
Assert.That(match.ScoreDifference, Is.EqualTo(-1));
}
public void GetAddressComponent_NotFound()
{
var addressComponents = new List <AddressComponent>()
{
new AddressComponent()
{
ShortName = "one",
Types = new List <string>()
{
"administrative_area_level_1",
"airport"
}
},
new AddressComponent()
{
ShortName = "two",
Types = new List <string>()
{
"country",
"geocode"
}
}
};
var types = new List <string>()
{
"floor"
};
GeocodeAddress.GetAddressComponent(addressComponents, types).Should().BeNull();
types = new List <string>()
{
"country"
};
GeocodeAddress.GetAddressComponent(addressComponents, types).Should().BeNull();
}
public GeocodeAddress requestGeocodeAddress(String address)
{
//Request the specified address to the geocode service using REST, the
// GET interface
//
String urlString = "http://geocoder.us/service/rest/geocode?address=" + HttpContext.Current.Server.UrlEncode(address);
HttpWebRequest getRequest = (HttpWebRequest)WebRequest.Create(urlString);
getRequest.Method = "GET";
WebResponse response = null;
try
{
response = getRequest.GetResponse();
}
catch (Exception)
{
return null;
}
Stream responseStream = response.GetResponseStream();
//Extract address elements from the XML response
//
//
GeocodeAddress addr = new GeocodeAddress();
try
{
XmlDocument doc = new XmlDocument();
doc.Load(responseStream);
//get the longitude and latitude
addr.lon = doc.GetElementsByTagName("geo:long").Item(0).FirstChild.Value;
addr.lat = doc.GetElementsByTagName("geo:lat").Item(0).FirstChild.Value;
//get and decompose address
address = doc.GetElementsByTagName("dc:description").Item(0).FirstChild.Value;
int sep = address.IndexOf(',');
if (sep != -1)
{
addr.address1 = address.Substring(0, sep);
addr.address2 = address.Substring(sep + 1);
}
else
addr.address1 = address;
}
catch (Exception e)
{
return null;
}
return addr;
}
