Example #1
0
 public EditGeocoderViewModel()
 {
     _configuration = new GeocoderSettings();
 }
 public BingGeocoder(IGeocoderHttpClient geocoderHttpClient, GeocoderSettings geocoderSettings, ILogger <BingGeocoder> logger)
 {
     this.geocoderHttpClient = geocoderHttpClient;
     this.geocoderSettings   = geocoderSettings;
     this.logger             = logger;
 }
        public async void AddGeocoderDataSet(FeatureTable table, GeocoderSettings geocoder)
        {
            try
            {
                _cancel = false;
                Logging.LogMethodCall(ClassName, () => new Dictionary <String, object> {
                    { nameof(table), table }, { nameof(geocoder), geocoder }
                });
                bool blHouseNumberField = false, blLeftFromField = false, blLeftToField = false, blRightFromField = false, blRightToField = false, blPreDirField = false, blStreetNameField = false, blStreetTypeField = false, blSufDirField = false, blAptNumberField = false, blZoneField = false;
                int  flds = 0;
                if ((blHouseNumberField = !string.IsNullOrWhiteSpace(geocoder.HouseNumberField)) && table.Fields.Any(fld => fld.Name == geocoder.HouseNumberField))
                {
                    flds++;
                }
                if ((blLeftFromField = !string.IsNullOrWhiteSpace(geocoder.LeftFromField)) && table.Fields.Any(fld => fld.Name == geocoder.LeftFromField))
                {
                    flds++;
                }
                if ((blLeftToField = !string.IsNullOrWhiteSpace(geocoder.LeftToField)) && table.Fields.Any(fld => fld.Name == geocoder.LeftToField))
                {
                    flds++;
                }
                if ((blRightFromField = !string.IsNullOrWhiteSpace(geocoder.RightFromField)) && table.Fields.Any(fld => fld.Name == geocoder.RightFromField))
                {
                    flds++;
                }
                if ((blRightToField = !string.IsNullOrWhiteSpace(geocoder.RightToField)) && table.Fields.Any(fld => fld.Name == geocoder.RightToField))
                {
                    flds++;
                }
                if ((blPreDirField = !string.IsNullOrWhiteSpace(geocoder.PreDirField)) && table.Fields.Any(fld => fld.Name == geocoder.PreDirField))
                {
                    flds++;
                }
                if ((blStreetNameField = !string.IsNullOrWhiteSpace(geocoder.StreetNameField)) && table.Fields.Any(fld => fld.Name == geocoder.StreetNameField))
                {
                    flds++;
                }
                if ((blStreetTypeField = !string.IsNullOrWhiteSpace(geocoder.StreetTypeField)) && table.Fields.Any(fld => fld.Name == geocoder.StreetTypeField))
                {
                    flds++;
                }
                if ((blSufDirField = !string.IsNullOrWhiteSpace(geocoder.SufDirField)) && table.Fields.Any(fld => fld.Name == geocoder.SufDirField))
                {
                    flds++;
                }
                if ((blAptNumberField = !string.IsNullOrWhiteSpace(geocoder.AptNumberField)) && table.Fields.Any(fld => fld.Name == geocoder.AptNumberField))
                {
                    flds++;
                }
                if ((blZoneField = !string.IsNullOrWhiteSpace(geocoder.ZoneField)) && table.Fields.Any(fld => fld.Name == geocoder.ZoneField))
                {
                    flds++;
                }
                if (flds == 0)
                {
                    ErrorHelper.OnMessage("No address records available for (" + geocoder.LayerName + ").");
                }
                else
                {
                    var qf = new QueryParameters();
                    qf.WhereClause = "1=1";
                    var result = await table.QueryFeaturesAsync(qf);

                    var ds = new GeocodeDataset
                    {
                        Name          = geocoder.LayerName,
                        MinMatchScore = geocoder.MinMatchScore
                    };
                    foreach (Feature row in result)
                    {
                        String address = String.Empty;

                        switch (geocoder.Type)
                        {
                        case GeocoderTypes.SingleField:
                            address = getDictionaryValue(row.Attributes, geocoder.StreetNameField, blStreetNameField);
                            break;

                        case GeocoderTypes.SingleHouse:
                            address = String.Format("{0} {1} {2} {3} {4} {5}",
                                                    getDictionaryValue(row.Attributes, geocoder.HouseNumberField, blHouseNumberField),
                                                    getDictionaryValue(row.Attributes, geocoder.AptNumberField, blAptNumberField),
                                                    getDictionaryValue(row.Attributes, geocoder.PreDirField, blPreDirField),
                                                    getDictionaryValue(row.Attributes, geocoder.StreetNameField, blStreetNameField),
                                                    getDictionaryValue(row.Attributes, geocoder.StreetTypeField, blStreetTypeField),
                                                    getDictionaryValue(row.Attributes, geocoder.SufDirField, blSufDirField));
                            break;
                            //case GeocoderTypes.SingleRange:
                            //    continue;
                            //case GeocoderTypes.DualRange:
                            //    continue;
                        }
                        if (string.IsNullOrWhiteSpace(address))
                        {
                            continue;
                        }
                        GeocodeRecord gr = new GeocodeRecord
                        {
                            AddressStandardized = StandardizeAddress(address),
                            Location            = row.Geometry
                        };
                        gr.AddressStandardized.Zone = getDictionaryValue(row.Attributes, geocoder.ZoneField, blZoneField);

                        string soundex = gr.AddressStandardized.StreetNameSoundex;
                        if (!ds.RecordFamilies.ContainsKey(soundex))
                        {
                            ds.RecordFamilies.Add(soundex, new List <GeocodeRecord>());
                        }
                        ds.RecordFamilies[soundex].Add(gr);
                        if (_cancel)
                        {
                            return;
                        }
                    }
                    if (ds.RecordFamilies.Count > 0)
                    {
                        GeocoderDatasets.Add(ds);
                        GeocoderAvailable = true;
                    }
                    else
                    {
                        ErrorHelper.OnMessage("No address fields found for  (" + geocoder.LayerName + ").");
                    }
                }
            }
            catch (Exception ex)
            {
                ErrorHelper.OnError(MethodBase.GetCurrentMethod().DeclaringType.Name, "Error setting up geocoder", ex);
            }
        }