/// <summary>
/// Geocodes array of addresses.
/// </summary>
/// <param name="addresses">Array of addresses.</param>
/// <returns>Returns array of best candidates for each input address.</returns>
/// <exception cref="System.ArgumentNullException"><paramref name="addresses"/> or any of
/// its elements is a null reference.</exception>
public override AddressCandidate[] BatchGeocode(Address[] addresses)
{
// "addresses" array elements will be validated by the Geocode method, so check only
// the array itself here.
CodeContract.RequiresNotNull("addresses", addresses);
var candidates = new List<AddressCandidate>();
foreach (var address in addresses)
{
var candidate = this.Geocode(address);
if (candidate != null)
{
candidates.Add(candidate);
}
}
return candidates.ToArray();
}
/// <summary>
/// Checks if the specified address is parsed.
/// </summary>
/// <param name="address">The reference to the address object to be checked.</param>
/// <returns>True if and only if the address was parsed.</returns>
public static bool IsParsed(Address address)
{
Debug.Assert(address != null);
var manuallyEditedXY = Application.Current.FindString(MANUALLY_EDITED_MATCH_METHOD_KEY);
// Address of candidates with "Edited X/Y" match method is not need to be parsed.
// Address with filled parts such as postal code, state etc is not need to be parsed.
var isParsed =
string.IsNullOrEmpty(address.FullAddress) ||
string.Equals(address.MatchMethod, manuallyEditedXY) ||
!_IsAllAddressPartsFieldsEmpty(address);
return isParsed;
}
/// <summary>
/// Combine full address from address fields.
/// </summary>
/// <param name="address">Address to set field.</param>
public static void SetFullAddress(Address address)
{
string fullAddress = string.Empty;
fullAddress = _AddAddressPart(address[AddressPart.Unit], fullAddress);
fullAddress = _AddAddressPart(address[AddressPart.AddressLine], fullAddress);
fullAddress = _AddAddressPart(address[AddressPart.Locality1], fullAddress);
fullAddress = _AddAddressPart(address[AddressPart.Locality2], fullAddress);
fullAddress = _AddAddressPart(address[AddressPart.Locality3], fullAddress);
fullAddress = _AddAddressPart(address[AddressPart.CountyPrefecture], fullAddress);
fullAddress = _AddAddressPart(address[AddressPart.StateProvince], fullAddress);
fullAddress = _AddAddressPart(address[AddressPart.PostalCode1], fullAddress);
fullAddress = _AddAddressPart(address[AddressPart.PostalCode2], fullAddress);
fullAddress = _AddAddressPart(address[AddressPart.Country], fullAddress);
address.FullAddress = fullAddress;
}
/// <summary>
/// Create RecordSet for Addresses.
/// </summary>
/// <param name="addresses">Addresses to make batch geocode.</param>
/// <returns>Addresses record set.</returns>
private RecordSet _GetAddressesRecordSet(Address[] addresses)
{
RecordSet addressTable = new RecordSet();
addressTable.Fields = _GetAddressFieldsForBatchGeocoding();
addressTable.Records = _GetAddressValuesForBatchGeocoding(addresses);
return addressTable;
}
/// <summary>
/// clones the current Address instance.
/// </summary>
/// <returns>A new <see cref="T:ESRI.ArcLogistics.DomainObjects.Address"/> object equal to
/// this one.</returns>
public Address Clone()
{
Address obj = new Address();
this.CopyTo(obj);
return obj;
}
/// <summary>
/// Do batch geocode request for several addresses.
/// </summary>
/// <param name="addresses">Source addresses.</param>
/// <returns>Address candidates.</returns>
private AddressCandidate[] _GeocodePart(Address[] addresses)
{
Debug.Assert(addresses != null);
RecordSet addressesSet = _GetAddressesRecordSet(addresses);
// Get propertyset for service from address.
PropertySet fieldMappingSet = _GetFieldMappingPropertySet();
RecordSet geocodedAddress = null;
AddressCandidate[] addressCandidates = null;
try
{
// Get recordset of geocoded address.
geocodedAddress = _client.GeocodeAddresses(addressesSet, fieldMappingSet, _propMods);
}
catch (System.ServiceModel.FaultException ex)
{
Logger.Info(ex);
}
// Get address candidate array from recordset of geocoded address.
if (geocodedAddress != null)
{
addressCandidates = _GetAllAddressCandidates(geocodedAddress, false);
}
return addressCandidates;
}
/// <summary>
/// Get AddressCandidate from geocode service response.
/// </summary>
/// <param name="geocodedAddress">Geocode service response.</param>
/// <returns>Geocoded AddressCandidate.</returns>
private AddressCandidate _GetAddressCandidate(PropertySet geocodedAddress)
{
AddressCandidate result = new AddressCandidate();
Address address = new Address();
result.Address = address;
// Look for needed properties and put them in to AddressCandidate.
foreach (PropertySetProperty property in geocodedAddress.PropertyArray)
{
if (property.Key.Equals(SHAPE_PROPERTY_KEY, StringComparison.OrdinalIgnoreCase))
{
PointN locationN = (PointN)property.Value;
result.GeoLocation = new ESRI.ArcLogistics.Geometry.Point(locationN.X, locationN.Y); ;
}
else if (property.Key.Equals(SCORE_PROPERTY_KEY, StringComparison.OrdinalIgnoreCase))
result.Score = Convert.ToInt16(property.Value);
else if (property.Key.Equals(MATCHADDR_PROPERTY_KEY, StringComparison.OrdinalIgnoreCase))
address.FullAddress = (string)property.Value ?? string.Empty;
else if (property.Key.Equals(LOCNAME_PROPERTY_KEY, StringComparison.OrdinalIgnoreCase))
address.MatchMethod = (string)property.Value ?? string.Empty;
}
if (!_UpdateLocatorProperties(result))
{
result = null;
}
return result;
}
/// <summary>
/// Is all fields of address is empty.
/// </summary>
/// <param name="address">Address to check.</param>
/// <returns>Is all fields of address is empty.</returns>
private bool _IsAddressFieldsEmpty(Address address)
{
Debug.Assert(address != null);
bool isAddressEmpty = true;
foreach (var addressPart in EnumHelpers.GetValues<AddressPart>())
{
if (!string.IsNullOrEmpty(address[addressPart]))
{
isAddressEmpty = false;
break;
}
}
return isAddressEmpty;
}
/// <summary>
/// Save manual order geocoding results to local storage.
/// </summary>
/// <param name="geocodable">Geocoding object.</param>
/// <param name="oldAddress">Address before geocoding.</param>
private void _SaveToLocalAddressNameStorage(IGeocodable geocodable, Address oldAddress)
{
// Do nothing in case of geocodable object is location.
Order order = geocodable as Order;
if (order != null)
{
NameAddressRecord nameAddressRecord = CommonHelpers.CreateNameAddressPair(order, oldAddress);
// Do save in local storage.
App.Current.NameAddressStorage.InsertOrUpdate(nameAddressRecord,
App.Current.Geocoder.AddressFormat);
}
}
/// <summary>
/// Validates geolocation candidates by streets geocoder.
/// </summary>
/// <param name="addresses">Address to geocode.</param>
/// <param name="candidates">Geocded candidates.</param>
private void _ValidateLocation(Address[] addresses, AddressCandidate[] candidates)
{
Debug.Assert(null != addresses); // created
Debug.Assert(null != candidates); // created
Debug.Assert(candidates.Length == addresses.Length); // valid stated
Debug.Assert(null != _checker); // inited
// init location validator
var streetsGeocoder = App.Current.StreetsGeocoder;
var locationValidator = new LocationValidator(streetsGeocoder);
// do validation
var incorrectCandidates = locationValidator
.FindIncorrectLocations(candidates)
.GroupBy(index => addresses[index])
.ToArray();
// get incorrect candidate indexes
var addressesForGeocoding = incorrectCandidates
.Select(item => item.Key)
.ToArray();
_checker.ThrowIfCancellationRequested();
// regeocoding by streets geocoder
var fixedCandidates = streetsGeocoder.BatchGeocode(addressesForGeocoding);
// update regeocoded candidates
for (var index = 0; index < fixedCandidates.Length; ++index)
{
_checker.ThrowIfCancellationRequested();
foreach (var j in incorrectCandidates[index])
{
candidates[j] = fixedCandidates[index];
}
}
}
/// <summary>
/// Read record from database.
/// </summary>
/// <param name="reader">Database reader.</param>
/// <returns>Readed record.</returns>
private NameAddressRecord _ReadRecord(SqlCeDataReader reader)
{
NameAddressRecord nameAddressRecord = new NameAddressRecord();
NameAddress nameAddress = new NameAddress();
nameAddressRecord.NameAddress = nameAddress;
nameAddress.Name = (string)reader[NAME_FIELD_NAME];
Address address = new Address();
nameAddress.Address = address;
address.Unit = (string)reader[UNIT_FIELD_NAME];
address.AddressLine = (string)reader[ADDRESSLINE_FIELD_NAME];
address.Locality1 = (string)reader[LOCALITY1_FIELD_NAME];
address.Locality2 = (string)reader[LOCALITY2_FIELD_NAME];
address.Locality3 = (string)reader[LOCALITY3_FIELD_NAME];
address.CountyPrefecture = (string)reader[COUNTYPREFECTURE_FIELD_NAME];
address.PostalCode1 = (string)reader[POSTALCODE1_FIELD_NAME];
address.PostalCode2 = (string)reader[POSTALCODE2_FIELD_NAME];
address.StateProvince = (string)reader[STATEPROVINCE_FIELD_NAME];
address.Country = (string)reader[COUNTRY_FIELD_NAME];
address.FullAddress = (string)reader[FULL_ADDRESS_FIELD_NAME];
float x = (float)reader[X_FIELD_NAME];
float y = (float)reader[Y_FIELD_NAME];
nameAddressRecord.GeoLocation = new ESRI.ArcLogistics.Geometry.Point(x, y);
Address matchedAddress = new Address();
nameAddressRecord.MatchedAddress = matchedAddress;
matchedAddress.Unit = (string)reader[MUNIT_FIELD_NAME];
matchedAddress.AddressLine = (string)reader[MADDRESSLINE_FIELD_NAME];
matchedAddress.Locality1 = (string)reader[MLOCALITY1_FIELD_NAME];
matchedAddress.Locality2 = (string)reader[MLOCALITY2_FIELD_NAME];
matchedAddress.Locality3 = (string)reader[MLOCALITY3_FIELD_NAME];
matchedAddress.CountyPrefecture = (string)reader[MCOUNTYPREFECTURE_FIELD_NAME];
matchedAddress.PostalCode1 = (string)reader[MPOSTALCODE1_FIELD_NAME];
matchedAddress.PostalCode2 = (string)reader[MPOSTALCODE2_FIELD_NAME];
matchedAddress.StateProvince = (string)reader[MSTATEPROVINCE_FIELD_NAME];
matchedAddress.Country = (string)reader[MCOUNTRY_FIELD_NAME];
matchedAddress.FullAddress = (string)reader[MFULL_ADDRESS_FIELD_NAME];
string matchMethod = (string)reader[MATCHMETHOD_FIELD_NAME];
if (CommonHelpers.IsAllAddressFieldsEmpty(matchedAddress) && string.IsNullOrEmpty(matchedAddress.MatchMethod))
{
address.MatchMethod = matchMethod;
}
else
{
matchedAddress.MatchMethod = matchMethod;
}
return nameAddressRecord;
}
/// <summary>
/// Creates address list for input objects.
/// </summary>
/// <param name="objects">Source object.</param>
/// <returns>Created address list for input objects.</returns>
/// <remarks>Progress show.</remarks>
private Address[] _CreateAddressList(IList<AppData.DataObject> objects)
{
Debug.Assert(null != objects); // created
Debug.Assert(0 < objects.Count); // not empty
Debug.Assert(null != _checker); // inited
// init progress
int count = objects.Count;
var addresses = new Address[count];
for (int index = 0; index < count; ++index)
{
_checker.ThrowIfCancellationRequested();
IGeocodable geocodable = _GetGeocodable(objects[index]);
addresses[index] = geocodable.Address;
}
return addresses;
}
/// <summary>
/// Handles asynchronous reverse geocoding completion.
/// </summary>
/// <param name="sender">The sender of the event.</param>
/// <param name="e">The event arguments object.</param>
private void _ClientReverseGeocodeCompleted(
object sender,
AsyncOperationCompletedEventArgs<ReverseGeocodeResponse> e)
{
// Do nothing if we get no result.
if (e.Cancelled)
{
return;
}
// There is just no way to report about errors occurred, so just log it and do nothing.
if (e.Error != null)
{
Logger.Warning(e.Error);
return;
}
if (e.Result == null || e.Result.Address == null)
{
return;
}
// Translate received event into this.AsyncReverseGeocodeCompleted event.
var address = new Address
{
FullAddress = e.Result.Address,
};
var eventArguments = new AsyncReverseGeocodedEventArgs(
address,
e.Result.Location,
e.UserState);
this.AsyncReverseGeocodeCompleted(this, eventArguments);
}
/// <summary>
/// Geocodes address and returns array of found candidates.
/// </summary>
/// <param name="address">Address to geocode.</param>
/// <param name="includeDisabledLocators">Is need to add candidates from disabled locators.</param>
/// <returns>Returns array of found address candidates.</returns>
/// <exception cref="System.ArgumentNullException"><paramref name="address"/> is a null
/// reference.</exception>
public override AddressCandidate[] GeocodeCandidates(Address address, bool includeDisabledLocators)
{
CodeContract.RequiresNotNull("address", address);
var response = _client.FindAddressCandidates(
address.FullAddress,
address.Country,
null);
if (response == null)
return null;
// Convert address candidates to the internal application objects.
var candidates = response.Candidates
.Select(_Convert)
.ToArray();
return candidates;
}
/// <summary>
/// Geocodes an address and returns the best candidate.
/// </summary>
/// <param name="address">Address to geocode.</param>
/// <returns>Returns address candidate with max score.</returns>
/// <exception cref="ESRI.ArcLogistics.AuthenticationException">
/// Is thrown if server state is unauthorized.</exception>
public override AddressCandidate Geocode(Address address)
{
_ValidateGeocoderState();
Debug.Assert(address != null);
// Get propertyset for service from address.
PropertySet addressSet = _GetPropertySet(address);
PropertySet geocodedAddress = null;
try
{
// Get propertyset of geocoded address.
geocodedAddress = _client.GeocodeAddress(addressSet, _propMods);
}
catch (System.ServiceModel.FaultException ex)
{
Logger.Info(ex);
}
if (geocodedAddress == null)
{
return null;
}
// Get address candidate from propertyset of geocoded address.
var addressCandidate = _GetAddressCandidate(geocodedAddress);
var hasPrimaryLocator =
addressCandidate == null ||
addressCandidate.Locator == null ||
addressCandidate.Locator.Primary;
if (!hasPrimaryLocator)
{
addressCandidate = null;
}
return addressCandidate;
}
/// <summary>
/// Convert local storage record to address candidate.
/// </summary>
/// <param name="nameAddressRecord">Local storage record.</param>
/// <returns>Address candidate.</returns>
private AddressCandidate _ConvertToCandidate(NameAddressRecord nameAddressRecord)
{
Debug.Assert(nameAddressRecord != null);
AddressCandidate candidateFromLocalStorage = new AddressCandidate();
// Candidate from local storage have maximum score.
candidateFromLocalStorage.Score = MAXIMUM_SCORE;
// Set candidate geolocation.
candidateFromLocalStorage.GeoLocation = new ESRI.ArcLogistics.Geometry.Point(
nameAddressRecord.GeoLocation.X, nameAddressRecord.GeoLocation.Y);
// Set candidate address.
Address candidateAddress = new Address();
candidateFromLocalStorage.Address = candidateAddress;
Address matchedAddress = nameAddressRecord.MatchedAddress;
Address address = nameAddressRecord.NameAddress.Address;
Address addressToCopy;
if (CommonHelpers.IsAllAddressFieldsEmpty(matchedAddress) && string.IsNullOrEmpty(matchedAddress.MatchMethod))
{
addressToCopy = address;
}
else
{
addressToCopy = matchedAddress;
}
addressToCopy.CopyTo(candidateAddress);
GeocodeHelpers.SetFullAddress(candidateAddress);
// Set locator.
foreach (LocatorInfo locator in App.Current.Geocoder.Locators)
{
if (locator.Title.Equals(candidateFromLocalStorage.Address.MatchMethod,
System.StringComparison.OrdinalIgnoreCase) ||
locator.Name.Equals(candidateFromLocalStorage.Address.MatchMethod,
System.StringComparison.OrdinalIgnoreCase))
{
candidateFromLocalStorage.Locator = locator;
break;
}
}
candidateFromLocalStorage.AddressType = ArcGiscomGeocoder.LocalStorageAddressType;
return candidateFromLocalStorage;
}
/// <summary>
/// Geocodes address and returns array of found candidates.
/// </summary>
/// <param name="address">Address to geocode.</param>
/// <param name="includeDisabledLocators">Is need to add candidates from disabled locators.</param>
/// <returns>Returns array of found address candidates.</returns>
/// <exception cref="ESRI.ArcLogistics.AuthenticationException">
/// Is thrown if server state is unauthorized.</exception>
public override AddressCandidate[] GeocodeCandidates(Address address, bool includeDisabledLocators)
{
_ValidateGeocoderState();
Debug.Assert(address != null);
// Get propertyset for service from address.
PropertySet addressSet = _GetPropertySet(address);
RecordSet geocodedAddress = null;
try
{
// Get recordset of geocoded address.
geocodedAddress = _client.FindAddressCandidates(addressSet, _propMods);
}
catch (System.ServiceModel.FaultException ex)
{
Logger.Info(ex);
}
// Get address candidate array from recordset of geocoded address.
if (geocodedAddress == null)
{
return null;
}
var addressCandidates = _GetNeededAddressCandidates(
geocodedAddress,
includeDisabledLocators);
return addressCandidates;
}
/// <summary>
/// Execute geocoding candidates.
/// </summary>
/// <param name="address">Address for geocoding.</param>
/// <param name="includeDisabledLocators">Is need to add candidates from disabled locators.</param>
/// <returns>Address candidates list.</returns>
private List<AddressCandidate> _GeocodeCandidates(Address address, bool includeDisabledLocators)
{
Debug.Assert(address != null);
Debug.Assert(_geocoder != null);
List<AddressCandidate> candidatesList = null;
// Clean old geocoding info.
address.MatchMethod = string.Empty;
if (App.Current.Geocoder.AddressFormat == AddressFormat.MultipleFields)
address.FullAddress = string.Empty;
else
{
// Do nothing: do not clear full address since
// it is used for geocoding in Single Address Field Format.
}
// Find all candidates.
AddressCandidate[] candidatesArr = _geocoder.GeocodeCandidates(address, includeDisabledLocators);
candidatesList = new List<AddressCandidate>();
if (candidatesArr != null)
{
candidatesList.AddRange(candidatesArr);
}
return candidatesList;
}
/// <summary>
/// Get address from property set response.
/// </summary>
/// <param name="propertySet">Property set.</param>
/// <returns>Address.</returns>
private Address _GetAddress(PropertySet propertySet)
{
Address address = new Address();
foreach (PropertySetProperty prop in propertySet.PropertyArray)
{
// Try to extract address field.
int fieldCount = _addressFields.Length;
for (int index = 0; index < fieldCount; index++)
{
if (prop.Key.Equals(_locatorFieldNames[index], StringComparison.OrdinalIgnoreCase))
{
AddressPart addressPart = _addressFields[index].Type;
address[addressPart] = _RemoveDuplicateWhiteSpace((string)prop.Value);
break;
}
}
// Try to extract locator name.
if (prop.Key.Equals(LOCNAME_PROPERTY_KEY, StringComparison.OrdinalIgnoreCase))
{
string locName = (string)prop.Value;
address.MatchMethod = locName ?? string.Empty;
}
}
string fullAddress = "";
for (int index = 0; index < _addressFields.Length; index++)
{
AddressPart addressPart = _addressFields[index].Type;
if (address[addressPart] != null)
{
if (fullAddress.Length != 0 && address[addressPart].Length != 0)
fullAddress += ", ";
fullAddress += address[addressPart];
}
}
if (fullAddress.Length != 0)
address.FullAddress = fullAddress;
var candidate = new AddressCandidate
{
Address = address,
};
_UpdateLocatorProperties(candidate);
return address;
}
/// <summary>
/// Get address value, divided into two rows.
/// </summary>
/// <param name="address">Address to divide.</param>
/// <returns>Address value, divided into two rows.</returns>
private string _GetAddressValue(Address address)
{
string result;
// Show all address, except address line.
string fullAddress = address.FullAddress;
// Address line is before first separator.
int index = fullAddress.IndexOf(',');
if (index != -1)
{
result = address.FullAddress.Substring(0, index).Trim();
result += System.Environment.NewLine;
result += fullAddress.Substring(index + 1, fullAddress.Length - index - 1).Trim();
result = result.Trim();
}
else
{
result = fullAddress;
}
return result;
}
/// <summary>
/// Get AddressCandidate from record.
/// </summary>
/// <param name="record">Source record.</param>
/// <param name="pointFieldIndex">Index of point field.</param>
/// <param name="scoreFieldIndex">Index of score field.</param>
/// <param name="matchAddrFieldIndex">Index of match address field.</param>
/// <param name="locNameFieldIndex">Index of locator name field.</param>
/// <param name="includeDisabledLocators">Is need to add candidates from disabled locators.</param>
/// <param name="addrTypeIndex">Index of address type field.</param>
/// <returns>Address candidate.</returns>
private AddressCandidate _GetAddressCandidateFromRecord(Record record, int pointFieldIndex,
int scoreFieldIndex, int matchAddrFieldIndex, int locNameFieldIndex, bool includeDisabledLocators,
int addrTypeIndex)
{
AddressCandidate result = new AddressCandidate();
Address address = new Address();
result.Address = address;
PointN locationN = (PointN)record.Values[pointFieldIndex];
// Check that we got non null point in record.
if (locationN != null)
{
result.GeoLocation =
new ESRI.ArcLogistics.Geometry.Point(locationN.X, locationN.Y);
}
result.Score = Convert.ToInt16(record.Values[scoreFieldIndex]);
string matchAddr = (string)record.Values[matchAddrFieldIndex];
address.FullAddress = matchAddr ?? string.Empty;
string locName = string.Empty;
if (locNameFieldIndex != -1)
{
locName = (string)record.Values[locNameFieldIndex];
}
address.MatchMethod = locName ?? string.Empty;
// Assign address type property value.
string addrType = string.Empty;
if (addrTypeIndex != -1)
{
addrType = (string)record.Values[addrTypeIndex];
}
result.AddressType = addrType ?? string.Empty;
if (!_UpdateLocatorProperties(result) && !includeDisabledLocators)
{
result = null;
}
return result;
}
/// <summary>
/// Method gets address property, which has Locator Field Name as a Key and
/// Address as a Value.
/// </summary>
/// <param name="index">Index of address field.</param>
/// <param name="address">Source address.</param>
/// <returns>Property Set Property.</returns>
private PropertySetProperty _GetAddressProperty(int index, Address address)
{
PropertySetProperty property = new PropertySetProperty();
property.Key = _locatorFieldNames[index];
AddressPart addressPart = _addressFields[index].Type;
property.Value = address[addressPart];
return property;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <c>AsyncReverseGeocodedEventArgs</c> class.
/// </summary>
/// <param name="address">Found address.</param>
/// <param name="location">Address location.</param>
public AsyncReverseGeocodedEventArgs(Address address,
ESRI.ArcGIS.Client.Geometry.MapPoint location, object userState)
: base(null, false, userState)
{
_address = (Address)address.Clone();
_location = new ESRI.ArcGIS.Client.Geometry.MapPoint(location.X, location.Y);
}
/// <summary>
/// Method returns address values collection for batch geocoding.
/// </summary>
/// <param name="addresses">Addresses to make batch geocode.</param>
/// <returns>Collection of records with Address Values.</returns>
private Record[] _GetAddressValuesForBatchGeocoding(Address[] addresses)
{
List<Record> records = new List<Record>();
// Add address fields.
for (int index = 0; index < addresses.Length; index++)
{
List<object> values = new List<object>();
// Add unique Object Id (OID) to every address.
values.Add(index);
// Fill property set with only FullAddress part.
if (AddressFormat == AddressFormat.SingleField)
{
string value =
addresses[index][AddressPart.FullAddress] ?? string.Empty;
values.Add(value);
}
else if (AddressFormat == AddressFormat.MultipleFields)
{
var filteredValues = from field in _addressFields
where (field.Type != AddressPart.FullAddress)
select (addresses[index][field.Type] ?? string.Empty);
values.AddRange(filteredValues);
}
else
{
// Do nothing.
Debug.Assert(false);
}
Record record = new Record();
record.Values = values.ToArray();
records.Add(record);
}
return records.ToArray();
}
/// <summary>
/// Copies address parts to the target address.
/// </summary>
/// <param name="address">Target address.</param>
public void CopyTo(Address address)
{
address.Unit = _unit;
address.FullAddress = _fullAddress;
address.AddressLine = _addressLine;
address.Locality1 = _locality1;
address.Locality2 = _locality2;
address.Locality3 = _locality3;
address.CountyPrefecture = _countyPrefecture;
address.PostalCode1 = _postalCode1;
address.PostalCode2 = _postalCode2;
address.StateProvince = _stateProvince;
address.Country = _country;
address.MatchMethod = _matchMethod;
}
/// <summary>
/// Get property set for request to service.
/// </summary>
/// <param name="address">Source address.</param>
/// <returns>Property set for request to service.</returns>
private PropertySet _GetPropertySet(Address address)
{
List<PropertySetProperty> propertyArray = new List<PropertySetProperty>();
if (AddressFormat == AddressFormat.MultipleFields)
{
// Fill property set by address parts without FullAddress part.
for (int index = 0; index < _addressFields.Length; index++)
if (_addressFields[index].Type != AddressPart.FullAddress)
propertyArray.Add(_GetAddressProperty(index, address));
}
else if (AddressFormat == AddressFormat.SingleField)
{
// Fill property set with only FullAddress part.
for (int index = 0; index < _addressFields.Length; index++)
if (_addressFields[index].Type == AddressPart.FullAddress)
{
propertyArray.Add(_GetAddressProperty(index, address));
break; // Work done: we don't need any other fields.
}
}
else
{
// Do nothing.
}
PropertySet addressSet = new PropertySet();
addressSet.PropertyArray = propertyArray.ToArray();
return addressSet;
}
/// <summary>
/// Parse full address property and fill address fields.
/// </summary>
/// <param name="addressToParse">Address to parse and fill.</param>
public static void ParseAndFillAddress(Address addressToParse)
{
Debug.Assert(addressToParse != null);
// Get field mappings for locator of candidate.
AddressPart[] addressFieldTypes = _GetFieldMappingsForLocator(addressToParse.MatchMethod);
// Split match_addr.
string[] fieldsSeparator = new string[1];
fieldsSeparator[0] = ADDRESS_FIELDS_SEPARATOR;
string[] addressFields;
addressFields = addressToParse.FullAddress.Split(fieldsSeparator, StringSplitOptions.None);
// Fill address.
if (addressFields.Length != addressFieldTypes.Length)
{
// In case of field mappings length is not equals to splitted address parts count -
// fill maximum possible values.
string errorFmt = (string)App.Current.FindResource("WrongFieldCountInLocatorInfo");
string errorMessage = string.Format(errorFmt, addressToParse.MatchMethod);
Logger.Warning(errorMessage);
// Special case for errors in locator.
int fieldCount = addressFieldTypes.Length;
if (fieldCount > addressFields.Length)
fieldCount = addressFields.Length;
for (int index = 0; index < fieldCount; index++)
{
AddressPart addressPart = addressFieldTypes[index];
addressToParse[addressPart] = addressFields[index].Trim();
}
}
else
{
// Fill address fields in correct order.
for (int index = 0; index < addressFields.Length; index++)
{
AddressPart addressPart = addressFieldTypes[index];
addressToParse[addressPart] = addressFields[index].Trim();
}
}
}
/// <summary>
/// Geocodes array of addresses.
/// </summary>
/// <param name="addresses">Array of addresses.</param>
/// <returns>Returns array of best candidates for each input address.</returns>
/// <exception cref="ESRI.ArcLogistics.AuthenticationException">
/// Is thrown if server state is unauthorized.</exception>
public override AddressCandidate[] BatchGeocode(Address[] addresses)
{
_ValidateGeocoderState();
Debug.Assert(addresses != null);
List<Address> addressList = addresses.ToList();
List<AddressCandidate> candidatesList = new List<AddressCandidate>();
// Due to ArcGIS Online limitations on batch geocoding max addresses count - split array to several.
int startIndex = 0;
while (startIndex < addressList.Count)
{
int partCount = Math.Min(_maxAddressCount, addressList.Count - startIndex);
Address[] addressesPart = new Address[partCount];
addressList.CopyTo(startIndex, addressesPart, 0, partCount);
AddressCandidate[] addressCandidatesPart = null;
addressCandidatesPart = _GeocodePart(addressesPart);
if (addressCandidatesPart != null)
{
candidatesList.AddRange(addressCandidatesPart);
}
startIndex += _maxAddressCount;
}
AddressCandidate[] addressCandidates = candidatesList.ToArray();
return addressCandidates;
}
/// <summary>
/// Check is all address fields is empty.
/// </summary>
/// <param name="address">Address to check.</param>
/// <returns>Is all fields empty.</returns>
private static bool _IsAllAddressPartsFieldsEmpty(Address address)
{
bool isEmpty = string.IsNullOrEmpty(address.Unit) &&
string.IsNullOrEmpty(address.AddressLine) &&
string.IsNullOrEmpty(address.Locality1) &&
string.IsNullOrEmpty(address.Locality2) &&
string.IsNullOrEmpty(address.Locality3) &&
string.IsNullOrEmpty(address.CountyPrefecture) &&
string.IsNullOrEmpty(address.PostalCode1) &&
string.IsNullOrEmpty(address.PostalCode2) &&
string.IsNullOrEmpty(address.StateProvince) &&
string.IsNullOrEmpty(address.Country);
return isEmpty;
}
/// <summary>
/// Geocodes an address and returns the best candidate.
/// </summary>
/// <param name="address">Address to geocode.</param>
/// <returns>Returns address candidate with max score.</returns>
/// <exception cref="System.ArgumentNullException"><paramref name="address"/> is a null
/// reference.</exception>
public override AddressCandidate Geocode(Address address)
{
CodeContract.RequiresNotNull("address", address);
var response = _client.FindAddress(address.FullAddress, address.Country, null);
return _Convert(response);
}
