public string GetLatLongFromAddress(GoogleAddress address)
{
if (address.FormattedAddress == null)
{
return "<coordinate>\n" +
"<lat>unknown</lat>\n" +
"<lon>unknown</lon>\n" +
"</coordinate>";
}
XDocument doc = XDocument.Load(String.Format(ApiGeoCode, address.FormattedAddress.Replace(" ", "+")));
var result = doc.Descendants("result").Descendants("geometry").Descendants("location").FirstOrDefault();
if (result == null)
{
return "<coordinate>\n" +
"<lat>unknown</lat>\n" +
"<lon>unknown</lon>\n" +
"</coordinate>";
}
XElement lat = result.Descendants("lat").FirstOrDefault();
XElement lon = result.Descendants("lng").FirstOrDefault();
return "<coordinate>\n" +
"<lat>" + (lat != null ? lat.Value : "unknown") + "</lat>\n" +
"<lon>" + (lon != null ? lon.Value : "unknown") + "</lon>\n" +
"</coordinate>";
}
public static string GetAddress(double Lat, double Lon)
{
string sURL;
sURL = "http://maps.googleapis.com/maps/api/geocode/json?latlng=";
sURL += Lat.ToString().Replace(',', '.') + "," + Lon.ToString().Replace(',', '.');
sURL += "&sensor=false";
WebRequest wrGETURL;
wrGETURL = WebRequest.Create(sURL);
Stream objStream;
objStream = wrGETURL.GetResponse().GetResponseStream();
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(GoogleAddress));
StreamReader objReader = new StreamReader(objStream);
GoogleAddress data = (GoogleAddress)ser.ReadObject(objStream);
if (data.results == null || data.results.Count == 0)
{
return(null);
}
return(data.results[0].formatted_address);
}
/// <summary>
/// Determines whether the specified value is valid.
/// </summary>
/// <param name="value">The value.</param>
/// <returns>
/// <c>true</c> if the specified value is valid; otherwise, <c>false</c>.
/// </returns>
public override bool IsValid(object value)
{
var address = GetPropertyValue(value, AddressPropertyName);
if (address.IsNullOrEmpty())
{
return(AllowNull);
}
var geocoder = new GoogleGeoCoder(); // key not needed
var result = geocoder.GeoCode(address.Trim()).FirstOrDefault();
if (result == null)
{
// No results
return(false);
}
_result = result; // store so that other classes that inherit from this attribute can access the result without re-geocoding
SetPropertyValue(value, result.Coordinates.Latitude, LatitudePropertyName); // set latitude
SetPropertyValue(value, result.Coordinates.Longitude, LongitudePropertyName); // set longitude
var fullAddress = result.FormattedAddress; // (result.Street.HasValue() && result.Street.Trim().HasValue() ? result.Street + ", " : "") + result.City + " " + result.State + ", " + result.Country + " " + result.PostalCode;
SetPropertyValue(value, fullAddress, AddressPropertyName); // set exact address
return(true);
}
// Geocodes an address using the Bing Maps engine
public static Location SearchGoogle(string add)
{
try
{
// Calls the webservice
GoogleGeocoder geocoder = new GoogleGeocoder()
{
ApiKey = ConfigurationManager.AppSettings["GoogleApiKey"]
};
IEnumerable <Address> addresses = geocoder.Geocode(add);
// Selects the firt result
GoogleAddress g = (GoogleAddress)addresses.FirstOrDefault();
Location r = new Location();
r.Lat = addresses.FirstOrDefault().Coordinates.Latitude;
r.Lon = addresses.FirstOrDefault().Coordinates.Longitude;
r.Quality = g.LocationType.ToString();
r.Address = addresses.FirstOrDefault().FormattedAddress;
return(r);
}
catch (Exception Ex)
{
throw new Exception(Ex.Message);
}
}
private static async Task AddOrUpdateLocation(int id, GoogleAddress address)
{
using (var telegramContext = new TelegramContext())
{
await telegramContext.Database.EnsureCreatedAsync();
var locationProfile = await telegramContext.UserLocations.FindAsync(id);
if (locationProfile != null)
{
locationProfile.Latitude = address.Coordinates.Latitude;
locationProfile.Longitude = address.Coordinates.Longitude;
locationProfile.FormattedAddress = address.FormattedAddress;
locationProfile.IsAmerica = address.IsAmerica();
}
else
{
await telegramContext.UserLocations.AddAsync(
new UserLocation
{
Id = id,
Latitude = address.Coordinates.Latitude,
Longitude = address.Coordinates.Longitude,
FormattedAddress = address.FormattedAddress,
IsAmerica = address.IsAmerica()
}
);
}
await telegramContext.SaveChangesAsync();
}
}
public Task <(string Address, string Flag)> GetShortLocationAsync(GoogleAddress geocode)
{
var country = geocode.Components.FirstOrDefault(
x => x.Types.Any(y => y == GoogleAddressType.Country || y == GoogleAddressType.Establishment));
var addressTypes = geocode.Components.ToDictionary(x => x.Types.FirstOrDefault(), y => y)
.OrderBy(x => x.Key);
var state = addressTypes.FirstOrDefault(x => (x.Key >= GoogleAddressType.AdministrativeAreaLevel1) &
(x.Key <= GoogleAddressType.AdministrativeAreaLevel3)).Value;
var city = addressTypes.FirstOrDefault(x => (x.Key == GoogleAddressType.Locality) |
(x.Key == GoogleAddressType.ColloquialArea)).Value;
var sb = new StringBuilder();
string countryFlag = null;
try
{
countryFlag = EmojiExtensions.FromText($":flag_{country.ShortName.ToLower()}:").Name;
}
catch
{
// ignored
}
if (city != null)
{
sb.Append($"{city.LongName}, ");
}
if (state != null)
{
sb.Append($"{state.LongName}, ");
}
sb.Append(country.ShortName);
return(Task.FromResult((sb.ToString(), countryFlag)));
}
private RealEstate CreateRealEstate(CreateRealEstateViewModel realEstate, GoogleAddress addressFull)
{
var userId = this.User.Identity.GetUserId();
var currentlyLoggedUser = this.usersService.GetUserDetailsById(userId);
realEstate.Country = addressFull.Components[3].LongName;
realEstate.City = addressFull.Components[1].LongName;
var dbRealEstate = this.Mapper.Map <RealEstate>(realEstate);
dbRealEstate.PublisherId = userId;
if (currentlyLoggedUser.MyOwnAgencyId != null)
{
dbRealEstate.AgencyId = currentlyLoggedUser.MyOwnAgencyId;
}
dbRealEstate.Latitude = addressFull.Coordinates.Latitude;
dbRealEstate.Longitude = addressFull.Coordinates.Longitude;
var visitors = new VisitorsDetails();
visitors.AllUsers.Add(currentlyLoggedUser);
var visitorsDetailsId = this.visitorsService.Add(visitors);
dbRealEstate.VisitorsDetailsId = visitorsDetailsId;
dbRealEstate.VisitorsDetails = visitors;
return(dbRealEstate);
}
public async Task ReverseGeocode()
{
GoogleGeocoder geocoder = new GoogleGeocoder();
var addresses = await geocoder.ReverseGeocodeAsync(Latitude, Longitude);
GoogleAddress addr = addresses.Where(a => !a.IsPartialMatch).FirstOrDefault();
if (addr != null)
{
if (addr[GoogleAddressType.Country] != null)
{
Country = addr[GoogleAddressType.Country].LongName;
}
if (addr[GoogleAddressType.Locality] != null)
{
Locality = addr[GoogleAddressType.Locality].LongName;
}
if (addr[GoogleAddressType.AdministrativeAreaLevel1] != null)
{
AdminLevel1 = addr[GoogleAddressType.AdministrativeAreaLevel1].LongName;
}
if (addr[GoogleAddressType.AdministrativeAreaLevel2] != null)
{
AdminLevel2 = addr[GoogleAddressType.AdministrativeAreaLevel2].LongName;
}
if (addr[GoogleAddressType.AdministrativeAreaLevel3] != null)
{
AdminLevel3 = addr[GoogleAddressType.AdministrativeAreaLevel3].LongName;
}
}
}
public async Task <List <GoogleAddress> > GetAddressPosition(string address)
{
var url = EndPoints.GoogleAddressUrl(address);
var client = new HttpClient();
var json = client.GetStringAsync(url).Result;
var adds = new List <GoogleAddress>();
GooglePlaceSearchResponse resp = JsonConvert.DeserializeObject <GooglePlaceSearchResponse>(json);
try
{
foreach (var add in resp.Results)
{
var pos = new GoogleAddress
{
RequestedAddress = address,
FormattedAddress = add.Vicinity,
Lat = add.Geometry.Location.Lat,
Lon = add.Geometry.Location.Lng,
Name = add.Name,
Distance = TrackingHelper.Instance.CalculateDistance(add.Geometry.Location.Lat, add.Geometry.Location.Lng),
};
adds.Add(pos);
}
}
catch (Exception e)
{
}
return(adds.OrderBy(x => x.Distance).ToList());;
}
private void OlvAddresses_FormatRow(object sender, BrightIdeasSoftware.FormatRowEventArgs e)
{
GoogleAddress address = e.Model as GoogleAddress;
if (address.PlaceId == txtPlaceID.Text)
{
e.Item.BackColor = Color.LightGreen;
}
}
public async Task <List <Stop> > SearchStops(GoogleAddress googleAddress)
{
var stops = Db.SearchStopsNearAddress(googleAddress.Lat, googleAddress.Lon, 0.5, googleAddress.Name);
foreach (var stop in stops)
{
stop.IsDestinationStart = true;
}
return(stops);
}
//public static List<GeocodeAddress> Geocoder(string address)
//{
// List<GeocodeAddress> geocodeAddresses = new List<GeocodeAddress>();
// GoogleGeocoder geocoder = new GoogleGeocoder(ConfigurationManager.AppSettings["GoogleMapsApiKey"].ToString());
// IEnumerable<GoogleAddress> addresses = geocoder.Geocode(address).ToArray();
// if (addresses.Count() == 0)
// {
// geocodeAddresses.Add(new GeocodeAddress()
// {
// Status = GeocodeStatus.NotFound.ToString(),
// Source = "Google"
// });
// return geocodeAddresses;
// }
// foreach (GoogleAddress gaddress in addresses)
// {
// geocodeAddresses.Add(new GeocodeAddress()
// {
// Status = GoogleToGeocode[GoogleStatus.Ok].ToString(),
// Latitude = gaddress.Coordinates.Latitude,
// Longitude = gaddress.Coordinates.Longitude,
// Source = gaddress.Provider,
// SourceId = gaddress.PlaceId,
// FormattedAddress = gaddress.FormattedAddress,
// StreetNumber = GetComponentType(gaddress, GoogleAddressType.StreetNumber).LongName,
// StreetName = GetComponentType(gaddress, GoogleAddressType.Route).LongName,
// City = GetComponentType(gaddress, GoogleAddressType.Locality).LongName,
// County = GetComponentType(gaddress, GoogleAddressType.AdministrativeAreaLevel2).LongName,
// State = GetComponentType(gaddress, GoogleAddressType.AdministrativeAreaLevel1).LongName,
// Country = GetComponentType(gaddress, GoogleAddressType.Country).LongName,
// PostalCode = GetComponentType(gaddress, GoogleAddressType.PostalCode).LongName
// });
// }
// //Sleep the thread so we dont go over the limit per seconds with google maps.
// Thread.Sleep(100);
// return geocodeAddresses;
//}
public static GoogleAddressComponent GetComponentType(GoogleAddress address, GoogleAddressType type)
{
GoogleAddressComponent component;
if ((component = address.Components.Where(w => w.Types.Contains(type)).SingleOrDefault()) != null)
{
return(component);
}
return(new GoogleAddressComponent(null, null, null));
}
public static bool IsAmerica(this GoogleAddress address)
{
var americaCheck = from component in address.Components
where component.ShortName.Equals("US") &&
component.Types.Contains(GoogleAddressType.Country) &&
component.Types.Contains(GoogleAddressType.Political)
select component;
return(americaCheck.Any());
}
public async Task StorageService_GetAddresses()
{
var model = new GoogleAddress {
UserName = "******"
};
SetDocumentQuery("mentorbot", "addresses", "SELECT TOP 1000 * FROM addresses", model);
var result = await _service.GetAddressesAsync();
Assert.AreEqual("A", result[0].UserName);
}
private string ReverseGeoCodeCapturedCellIdToLocation(ulong capturedCellId)
{
var cellId = new S2CellId(capturedCellId);
var latlng = cellId.ToLatLng();
string location;
// Check cache for location.
bool success = PokemonListModel.LocationsCache.TryGetValue(this.PokemonData.CapturedCellId, out location);
if (success)
{
return(location);
}
GoogleGeocoder geocoder = new GoogleGeocoder();
var addresses = geocoder.ReverseGeocode(new Geocoding.Location(latlng.LatDegrees, latlng.LngDegrees));
GoogleAddress addr = addresses.Where(a => !a.IsPartialMatch).FirstOrDefault();
if (addr != null && addr[GoogleAddressType.Country] != null)
{
if (addr[GoogleAddressType.Locality] != null)
{
location = $"{addr[GoogleAddressType.Locality].LongName}, {addr[GoogleAddressType.Country].LongName}";
}
else if (addr[GoogleAddressType.AdministrativeAreaLevel1] != null)
{
location = $"{addr[GoogleAddressType.AdministrativeAreaLevel1].LongName}, {addr[GoogleAddressType.Country].LongName}";
}
else if (addr[GoogleAddressType.AdministrativeAreaLevel2] != null)
{
location = $"{addr[GoogleAddressType.AdministrativeAreaLevel2].LongName}, {addr[GoogleAddressType.Country].LongName}";
}
else if (addr[GoogleAddressType.AdministrativeAreaLevel3] != null)
{
location = $"{addr[GoogleAddressType.AdministrativeAreaLevel3].LongName}, {addr[GoogleAddressType.Country].LongName}";
}
else
{
location = $"{addr[GoogleAddressType.Country].LongName}";
}
// Add to cache
PokemonListModel.LocationsCache.Add(this.PokemonData.CapturedCellId, location);
}
else
{
location = $"{latlng.LatDegrees}, {latlng.LngDegrees}";
}
return(location);
}
public string ReverseGeocode(string ApiKey, double Latitude, double Longitude)
{
GoogleGeocoder coder = new GoogleGeocoder(ApiKey);
GoogleAddress address = coder.ReverseGeocode(Latitude, Longitude).FirstOrDefault();
if (address != null)
{
return(address.FormattedAddress);
}
else
{
return(null);
}
}
public LocationInfo Geocode(string input)
{
IGeocoder geocoder = new GoogleGeocoder();
IEnumerable <Address> addresses = geocoder.Geocode(input);
GoogleAddress address = (GoogleAddress)addresses.First();
return(new LocationInfo
{
Latitude = address.Coordinates.Latitude.ToString(),
Longitude = address.Coordinates.Longitude.ToString(),
City = address[GoogleAddressType.Locality].LongName,
State = address[GoogleAddressType.AdministrativeAreaLevel1].ShortName
});
}
// Geocodes an address using the Bing Maps engine
public static Location Geocode_Google(string ADDRESS)
{
try
{
// Calls the webservice
GoogleGeocoder GEOCODER = new GoogleGeocoder()
{
ApiKey = ConfigurationManager.AppSettings["GoogleApiKey"]
};
IEnumerable <Address> addresses = GEOCODER.Geocode(ADDRESS);
Location R = new Location();
// Checks if the process returned a valid result
if (addresses.Count() > 0)
{
// Selects the firt result
GoogleAddress G = (GoogleAddress)addresses.FirstOrDefault();
R.Lat = G.Coordinates.Latitude;
R.Lon = G.Coordinates.Longitude;
R.Address = Find_Value(G, "ROUTE") + " " +
Find_Value(G, "STREETNUMBER");
R.City = Find_Value(G, "ADMINISTRATIVEAREALEVEL2");
R.State = Find_Value(G, "ADMINISTRATIVEAREALEVEL1");
R.PostalCode = Find_Value(G, "POSTALCODE");
R.Quality = G.LocationType.ToString();
R.Complete = G.FormattedAddress;
}
else
{
R.Lat = 0;
R.Lon = 0;
R.Quality = "Bad";
}
return(R);
}
catch (Exception ERROR)
{
throw new Exception(ERROR.Message);
}
}
public Coordinates Geocode(string ApiKey, string Address)
{
GoogleGeocoder coder = new GoogleGeocoder(ApiKey);
GoogleAddress address = coder.Geocode(Address).FirstOrDefault();
if (address != null)
{
return new Coordinates()
{
Latitude = address.Coordinates.Latitude, Longitude = address.Coordinates.Longitude
}
}
;
else
{
return(null);
}
}
// Find a value into GoogleAddress IEnumerable
public static string Find_Value(GoogleAddress Obj, string Tag)
{
string V = "";
if (Obj.Components.Count() > 0)
{
for (int I = 0; I < Obj.Components.Count(); I++)
{
string[] Results = Obj.Components[I].ToString().Split(':');
if (Results[0].Trim().ToUpper() == Tag)
{
V = Obj.Components[I].ShortName;
break;
}
}
}
return(V);
}
private void MnuSetBasicAddress_Click(object sender, System.EventArgs e)
{
if (olvAddresses.SelectedObject == null)
{
return;
}
GoogleAddress basicAddress = olvAddresses.SelectedObject as GoogleAddress;
var allAddresses = olvAddresses.CollectCheckedObjects <Address>(ObjectListViewHelper.ObjectListViewCollector.All);
Bind sourceBind = this.BindAlternative ?? this.Bind;
BindAddress newBindAddress = BindAddress.Create(allAddresses, basicAddress);
Bind newBind = new Bind {
Address = newBindAddress, Addresses = allAddresses, Description = sourceBind.Description, OriginalAddress = sourceBind.OriginalAddress
};
this.BindAlternative = newBind;
UpdateBindInfo(newBind);
}
protected string GetGeoCode(sp_Vol_Address_DM VolAddr)
{
GoogleAddress googleAddress = new GoogleAddress();
googleAddress.FormattedAddress = VolAddr.AddrLine1 + ", " +
VolAddr.City + ", " + VolAddr.St + " " + VolAddr.Zip;
//Assume we want to send the request to Google using SSL
IGeocoder geoCoder = new GoogleGeocoder(true);
String geoCoderXML = geoCoder.GetLatLongFromAddress(googleAddress);
String latitude;
String longitude;
using (XmlReader reader = XmlReader.Create(new StringReader(geoCoderXML)))
{
reader.ReadToFollowing("lat");
reader.MoveToFirstAttribute();
latitude = reader.Value;
reader.ReadToFollowing("lon");
longitude = reader.Value;
}
String gcReturn;
if (latitude.Contains("unknown") || longitude.Contains("unknown"))
{
gcReturn = null;
}
else
{
gcReturn = "'POINT(" + longitude + " " + latitude + ")'";
}
return gcReturn;
}
/// <summary>Processes the specified timesheets.</summary>
private async Task ProcessNotify(
IReadOnlyList <Timesheet> timesheets,
string department,
bool notify,
GoogleChatAddress address,
IHangoutsChatConnector connector)
{
string text;
var filteredTimesheet =
department == null ?
timesheets :
timesheets
.Where(it => it.DepartmentName.Equals(department, StringComparison.InvariantCultureIgnoreCase))
.ToArray();
var notifiedUserList = new List <string>();
if (filteredTimesheet.Count == 0)
{
text = "<b>All user have submitted timesheets.</b>";
}
else if (notify && filteredTimesheet.Count > 0)
{
var emails = filteredTimesheet.Select(it => it.UserEmail).ToArray();
var storeAddresses = _storageService.GetAddresses();
var filteredAddresses = storeAddresses.Where(it => emails.Contains(it.UserEmail)).ToArray();
var addressesForUpdate = new List <GoogleAddress>();
IReadOnlyList <GoogleAddress> privateAddresses = new GoogleAddress[0];
if (filteredAddresses.Length < timesheets.Count)
{
var storeAddressesNames = storeAddresses.Select(it => it.SpaceName).ToArray();
privateAddresses = connector
.GetPrivateAddress(storeAddressesNames)
.Select(it => new GoogleAddress
{
SpaceName = it.Space.Name,
UserName = it.Sender.Name,
UserDisplayName = it.Sender.DisplayName
})
.ToArray();
// Store inactive spaces, so not to be requested the next time
addressesForUpdate.AddRange(privateAddresses.Where(it => it.UserName == null));
}
foreach (var timesheet in filteredTimesheet)
{
var message = $"{timesheet.UserName}, Please submit your timesheet. Your current hours are {timesheet.Total}.";
var addr = filteredAddresses.FirstOrDefault(it => it.UserEmail == timesheet.UserEmail);
if (addr == null)
{
addr = privateAddresses.FirstOrDefault(it => it.UserDisplayName == timesheet.UserName);
if (addr == null)
{
continue;
}
addr.UserEmail = timesheet.UserEmail;
addressesForUpdate.Add(addr);
}
notifiedUserList.Add(timesheet.UserName);
await connector.SendMessageAsync(
message,
new GoogleChatAddress(addr.SpaceName, string.Empty, "DM", addr.UserName, addr.UserDisplayName));
}
if (addressesForUpdate.Count > 0)
{
await _storageService.AddAddressesAsync(addressesForUpdate);
}
text = notifiedUserList.Count == filteredTimesheet.Count ?
"All users width unsubmitted timesheets are notified! Total of " + notifiedUserList.Count :
"The following people where not notified: <br>" + GetCardText(filteredTimesheet, notifiedUserList);
}
else
{
text = "The following people have to submit timesheet: <br>" + GetCardText(filteredTimesheet, notifiedUserList);
}
var paragraph = new TextParagraph {
Text = text
};
var card = ChatEventFactory.CreateCard(paragraph);
await connector.SendMessageAsync(null, address, card);
}
public async Task <(List <EmbedBuilder> WeatherResults, List <EmbedBuilder> Alerts)> GetWeatherEmbedsAsync(
DarkSkyResponse forecast, GoogleAddress geocode)
{
if (forecast.IsSuccessStatus)
{
var alertEmbeds = new List <EmbedBuilder>();
var weatherEmbeds = new List <EmbedBuilder>();
var response = forecast.Response;
(string address, string flag) = await GetShortLocationAsync(geocode).ConfigureAwait(false);
var hourlyDataPoint = response.Hourly.Data.FirstOrDefault();
if (hourlyDataPoint != null)
{
var weatherIcons = GetWeatherEmoji(hourlyDataPoint.Icon);
var color = CreateWeatherColor(hourlyDataPoint.Temperature);
var embed = new EmbedBuilder
{
Color = color,
Title = $"{flag ?? ""}{address}",
Description = $"Weather from {hourlyDataPoint.DateTime.Humanize()}",
Footer = new EmbedFooterBuilder
{
Text = "Powered by Dark Sky",
IconUrl = "https://darksky.net/images/darkskylogo.png"
},
ThumbnailUrl = weatherIcons.Url
}.WithCurrentTimestamp();
embed.AddField($"{weatherIcons.Emoji.Name} Summary", response.Hourly.Summary, true);
embed.AddField("🌡 Temperature",
$"{hourlyDataPoint.Temperature} °C / {hourlyDataPoint.Temperature * 1.8 + 32} °F", true);
embed.AddField("☂ Precipitation", string.Format("{0:P1}", hourlyDataPoint.PrecipProbability), true);
if (hourlyDataPoint.PrecipIntensity.HasValue && hourlyDataPoint.PrecipIntensity.Value > 0)
{
embed.AddField("💧 Precipitation Intensity", $"{hourlyDataPoint.PrecipIntensity} (mm/h)", true);
}
embed.AddField("💧 Humidity", string.Format("{0:P1}", hourlyDataPoint.Humidity), true);
embed.AddField("🌬 Wind Speed", $"{hourlyDataPoint.WindSpeed} (m/s)", true);
weatherEmbeds.Add(embed);
}
if (response.Alerts != null)
{
foreach (var alert in response.Alerts)
{
var expiration = alert.ExpiresDateTime;
string alertContent = alert.Description.Humanize();
if (alertContent.Length >= 512)
{
alertContent = alertContent.Truncate(512) +
"\n\nPlease click on the title for more details.";
}
var sb = new StringBuilder();
sb.AppendLine(Format.Bold(alert.Title));
sb.AppendLine();
sb.AppendLine(alertContent);
sb.AppendLine();
if (expiration > DateTimeOffset.UtcNow)
{
sb.AppendLine(Format.Italics($"Expires {expiration.Humanize()}"));
}
var alertEmbed = new EmbedBuilder
{
Color = Color.DarkOrange,
Title = $"Alert for {address}, click me for more details.",
Url = alert.Uri.AbsoluteUri,
ThumbnailUrl = _config.Icons.Warning,
Description = sb.ToString()
};
alertEmbeds.Add(alertEmbed);
}
}
return(weatherEmbeds, alertEmbeds);
}
_loggingService.Log($"Weather returned unexpected response: {forecast.ResponseReasonPhrase}",
LogSeverity.Error);
return(null, null);
}
public virtual async Task <ActionResult> Edit(PropertyListing model)
{
try
{
var modelToUpdate = await _property.GetPropertyByIdAsync(model.Id, true);
var updatedFields = Request.Form.Keys.ToHashSet();
modelToUpdate = modelToUpdate.UpdateFromFormModel(model, updatedFields);
modelToUpdate = await _property.ReloadReferences(modelToUpdate);
modelToUpdate.LastEditedBy = User.Identity.Name;
modelToUpdate.LastEditedOn = DateTime.UtcNow;
if (model.AutoGeocode)
{
var StatusMessage = "";
try
{
try
{
GoogleAddress address = _address.GeocodeAddress(modelToUpdate);
if (address != null)
{
modelToUpdate.SetLocation(address.Coordinates);
}
}
catch (Exception ex)
{
if (ex.InnerException != null)
{
throw ex.InnerException;
}
StatusMessage = "There was an error GeoLocating the property.";
ModelState.AddModelError("GeoCoding", StatusMessage);
await _logService.AddExceptionAsync <BasePropertyController>(StatusMessage, ex, LogType.Warning);
}
}
catch (GoogleGeocodingException ex)
{
switch (ex.Status)
{
case GoogleStatus.RequestDenied:
StatusMessage = "There was an error with the Google API [RequestDenied] this means your API account is not activated for Geocoding Requests.";
ModelState.AddModelError("GeoCoding", StatusMessage);
await _logService.AddExceptionAsync <BasePropertyController>(StatusMessage, ex, LogType.Warning);
break;
case GoogleStatus.OverQueryLimit:
StatusMessage = "There was an error with the Google API [OverQueryLimit] this means your API account is has run out of Geocoding Requests.";
ModelState.AddModelError("GeoCoding", StatusMessage);
await _logService.AddExceptionAsync <BasePropertyController>(StatusMessage, ex, LogType.Warning);
break;
default:
StatusMessage = "There was an error with the Google API [" + ex.Status.ToString() + "]: " + ex.Message;
ModelState.AddModelError("GeoCoding", StatusMessage);
await _logService.AddExceptionAsync <BasePropertyController>(StatusMessage, ex, LogType.Warning);
break;
}
}
}
string type = Engine.Settings.Property.GetPlanningFromType(modelToUpdate.Planning);
if (modelToUpdate.HasMeta("PlanningDescription"))
{
modelToUpdate.UpdateMeta("PlanningDescription", type);
}
else
{
if (modelToUpdate.Metadata == null)
{
modelToUpdate.Metadata = new List <PropertyMeta>();
}
modelToUpdate.AddMeta("PlanningDescription", type);
}
foreach (KeyValuePair <string, Microsoft.Extensions.Primitives.StringValues> val in Request.Form)
{
if (val.Key.StartsWith("Meta:"))
{
if (modelToUpdate.HasMeta(val.Key.Replace("Meta:", "")))
{
modelToUpdate.UpdateMeta(val.Key.Replace("Meta:", ""), val.Value.ToString());
}
else
{
modelToUpdate.AddMeta(val.Key.Replace("Meta:", ""), val.Value.ToString());
}
}
}
await _property.UpdateAsync(modelToUpdate);
SaveMessage = "Saved";
MessageType = AlertType.Success;
modelToUpdate = await LoadAgents(modelToUpdate);
return(View(modelToUpdate));
}
catch (Exception ex)
{
await _logService.AddExceptionAsync <BasePropertyController>("Error saving a property listing.", ex);
SaveMessage = "An error occurred: " + ex.Message;
MessageType = AlertType.Danger;
model = await _property.ReloadReferences(model);
model = await LoadAgents(model);
return(View(model));
}
}
/// <summary>
/// Maps a Google Address Object to the values of the dynamic form associated with the address country and returns the dynamic form.
/// </summary>
/// <exception cref="Flipdish.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="googleAddress">A Google address object, as it is retuned from the maps API.</param>
/// <returns>RestApiResultAddressFormResponse</returns>
public RestApiResultAddressFormResponse FormatGoogleAddress(GoogleAddress googleAddress)
{
ApiResponse <RestApiResultAddressFormResponse> localVarResponse = FormatGoogleAddressWithHttpInfo(googleAddress);
return(localVarResponse.Data);
}
private IList <ILocationAddress> OnProcessResponse(object responseResult, int maxResults, CancellationToken token)
{
if (IfCancellationRequested(token))
{
return(null);
}
if (responseResult == null)
{
return(null);
}
var json = responseResult as string;
if (string.IsNullOrEmpty(json) || string.IsNullOrWhiteSpace(json))
{
return(null);
}
var response = JsonConvert.DeserializeObject <GoogleResponse>(json);
if (response?.Status == null)
{
throw new GoogleGeocodingException(GoogleStatus.Error, new HttpRequestException("Empty response."));
}
if (response.Status != GoogleStatus.Ok && response.Status != GoogleStatus.ZeroResults)
{
throw new GoogleGeocodingException(response.Status, response.ErrorMessage);
}
if (response.Results == null || response.Results.Length == 0)
{
throw new GoogleGeocodingException(GoogleStatus.Error, response.ErrorMessage,
new HttpRequestException("Empty response result."));
}
var result = new List <ILocationAddress>();
if (response.Status == GoogleStatus.ZeroResults)
{
return(result);
}
var count = 0;
foreach (var respResult in response.Results.Where(p => p != null))
{
if (IfCancellationRequested(token))
{
return(null);
}
if (count++ >= maxResults)
{
break;
}
if (respResult.AddressComponents == null)
{
continue;
}
var address = new GoogleAddress("Google");
foreach (var component in respResult.AddressComponents.Where(p => p != null))
{
if (IfCancellationRequested(token))
{
return(null);
}
foreach (var compType in component.Type)
{
if (IfCancellationRequested(token))
{
return(null);
}
switch (compType)
{
case GoogleAddressType.PostalCode:
address.PostalCode = component.LongName;
continue;
case GoogleAddressType.Country:
address.CountryName = component.LongName;
address.CountryCode = component.ShortName;
continue;
case GoogleAddressType.AdministrativeAreaLevel1:
address.AdminArea = component.LongName;
continue;
case GoogleAddressType.AdministrativeAreaLevel2:
address.SubAdminArea = component.LongName;
continue;
case GoogleAddressType.Locality:
address.Locality = component.LongName;
continue;
case GoogleAddressType.SubLocalityLevel1:
address.SubLocality = component.LongName;
continue;
case GoogleAddressType.SubLocalityLevel2:
address.Thoroughfare = component.LongName;
continue;
case GoogleAddressType.SubLocalityLevel3:
address.SubThoroughfare = component.LongName;
continue;
case GoogleAddressType.Premise:
address.Premises = component.LongName;
continue;
default:
continue;
}
}
}
if (respResult.Geometry?.Location?.Latitude != null &&
respResult.Geometry.Location.Longitude.HasValue)
{
address.Latitude = respResult.Geometry.Location.Latitude.Value;
address.Longitude = respResult.Geometry.Location.Longitude.Value;
}
result.Add(address);
}
return(result);
}
/// <summary>
/// Maps a Google Address Object to the values of the dynamic form associated with the address country and returns the dynamic form.
/// </summary>
/// <exception cref="Flipdish.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="googleAddress">A Google address object, as it is retuned from the maps API.</param>
/// <returns>Task of RestApiResultAddressFormResponse</returns>
public async System.Threading.Tasks.Task <RestApiResultAddressFormResponse> FormatGoogleAddressAsync(GoogleAddress googleAddress)
{
ApiResponse <RestApiResultAddressFormResponse> localVarResponse = await FormatGoogleAddressAsyncWithHttpInfo(googleAddress);
return(localVarResponse.Data);
}
private static string FormatGeolocation(GoogleAddress address)
{
return(string.Format(Strings.GeocodeResult, address.FormattedAddress, address.Coordinates.Latitude,
address.Coordinates.Longitude));
}
/// <summary>
/// Maps a Google Address Object to the values of the dynamic form associated with the address country and returns the dynamic form.
/// </summary>
/// <exception cref="Flipdish.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="googleAddress">A Google address object, as it is retuned from the maps API.</param>
/// <returns>Task of ApiResponse (RestApiResultAddressFormResponse)</returns>
public async System.Threading.Tasks.Task <ApiResponse <RestApiResultAddressFormResponse> > FormatGoogleAddressAsyncWithHttpInfo(GoogleAddress googleAddress)
{
// verify the required parameter 'googleAddress' is set
if (googleAddress == null)
{
throw new ApiException(400, "Missing required parameter 'googleAddress' when calling AddressApi->FormatGoogleAddress");
}
var localVarPath = "/api/v1.0/address/google";
var localVarPathParams = new Dictionary <String, String>();
var localVarQueryParams = new List <KeyValuePair <String, String> >();
var localVarHeaderParams = new Dictionary <String, String>(this.Configuration.DefaultHeader);
var localVarFormParams = new Dictionary <String, String>();
var localVarFileParams = new Dictionary <String, FileParameter>();
Object localVarPostBody = null;
// to determine the Content-Type header
String[] localVarHttpContentTypes = new String[] {
"application/json",
"text/json",
"application/xml",
"text/xml",
"application/x-www-form-urlencoded"
};
String localVarHttpContentType = this.Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);
// to determine the Accept header
String[] localVarHttpHeaderAccepts = new String[] {
"application/json",
"text/json",
"application/xml",
"text/xml"
};
String localVarHttpHeaderAccept = this.Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
if (localVarHttpHeaderAccept != null)
{
localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
}
if (googleAddress != null && googleAddress.GetType() != typeof(byte[]))
{
localVarPostBody = this.Configuration.ApiClient.Serialize(googleAddress); // http body (model) parameter
}
else
{
localVarPostBody = googleAddress; // byte array
}
// authentication (oauth2) required
// oauth required
if (!String.IsNullOrEmpty(this.Configuration.AccessToken))
{
localVarHeaderParams["Authorization"] = "Bearer " + this.Configuration.AccessToken;
}
// make the HTTP request
IRestResponse localVarResponse = (IRestResponse)await this.Configuration.ApiClient.CallApiAsync(localVarPath,
Method.POST, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams, localVarFileParams,
localVarPathParams, localVarHttpContentType);
int localVarStatusCode = (int)localVarResponse.StatusCode;
if (ExceptionFactory != null)
{
Exception exception = ExceptionFactory("FormatGoogleAddress", localVarResponse);
if (exception != null)
{
throw exception;
}
}
return(new ApiResponse <RestApiResultAddressFormResponse>(localVarStatusCode,
localVarResponse.Headers.ToDictionary(x => x.Name, x => x.Value.ToString()),
(RestApiResultAddressFormResponse)this.Configuration.ApiClient.Deserialize(localVarResponse, typeof(RestApiResultAddressFormResponse))));
}
public ActionResult VerifyZipCode(string zipCode)
{
string city = null;
string state = null;
var request = Request;
//check if zipcode is a valid integer
if (int.TryParse(zipCode, out int parsedZip) == false)
{
return(new JsonResult()
{
Data = new { Success = false, Message = "Invalid ZipCode" }
});
}
//get city and state from geocode API
var geoCoder = new GoogleGeocoder()
{
ComponentFilters = new List <GoogleComponentFilter> {
new GoogleComponentFilter("country", "US"), new GoogleComponentFilter("postal_code", zipCode)
}
};
try
{
GoogleAddress address = geoCoder.Geocode(zipCode).FirstOrDefault();
if (address == null)
{
return(new JsonResult()
{
Data = new { Success = false, Message = "Invalid ZipCode" }
});
}
city = address.Components.Single(x => x.Types.Any(t => t == GoogleAddressType.Locality)).ShortName;
state = address.Components.Single(x => x.Types.Any(t => t == GoogleAddressType.AdministrativeAreaLevel1)).ShortName;
}
catch
{
return(new JsonResult()
{
Data = new { Success = false, Message = "Invalid ZipCode" }
});
}
//check if zip is serviced
var zipcode = db.ZipCodes.SingleOrDefault(z => z.Zip == parsedZip);
if (zipcode == null)
{
db.ZipCodes.Add(new ZipCode()
{
Zip = parsedZip, IsServiced = false
});
db.SaveChanges();
return(new JsonResult()
{
Data = new { Success = false, Message = db.Store.First().ZipCodeNotInServiceMessage }
});
}
else if (zipcode.IsServiced)
{
var order = db.Orders.Add(new Order()
{
ZipCode = zipcode,
DateOrdered = DateTime.Now,
Status = OrderStatus.Initial,
City = city,
State = state,
SubTotal = decimal.Zero,
GrandTotal = decimal.Zero,
DeliveryCharge = db.Store.First().DeliveryFee
});
db.SaveChanges();
return(new JsonResult()
{
Data = new { Success = true, Message = "Let's Order!", OrderId = order.OrderId }
});
}
else
{
return(new JsonResult()
{
Data = new { Success = false, Message = db.Store.First().ZipCodeNotInServiceMessage }
});
}
}
private async Task <IReadOnlyList <string> > NotifyUsersOverChatAsync(
IHangoutsChatConnector connector,
TimesheetStates state,
Timesheet[] timesheets)
{
var notifiedUserList = new List <string>();
var addressesForUpdate = new List <GoogleAddress>();
var storeAddresses = await _storageService.GetAddressesAsync();
var emails = timesheets.Select(it => it.UserEmail).ToArray();
var filteredAddresses = storeAddresses.Where(it => emails.Contains(it.UserEmail)).ToArray();
IReadOnlyList <GoogleAddress> privateAddresses = new GoogleAddress[0];
if (filteredAddresses.Length < timesheets.Length)
{
var storeAddressesNames = storeAddresses.Select(it => it.SpaceName).Distinct().ToArray();
privateAddresses = connector
.GetPrivateAddress(storeAddressesNames)
.Select(it => new GoogleAddress
{
SpaceName = it.Space.Name,
UserName = it.Sender.Name,
UserDisplayName = it.Sender.DisplayName
})
.ToArray();
// Store inactive spaces, so not to be requested the next time
addressesForUpdate.AddRange(privateAddresses.Where(it => it.UserName == null));
}
var textMessage = OpenAirText.GetText(state, OpenAirTextTypes.Notify);
foreach (var timesheet in timesheets)
{
var message = timesheet.UserName + textMessage;
var addr = filteredAddresses.FirstOrDefault(it => it.UserEmail == timesheet.UserEmail);
if (addr == null)
{
addr = privateAddresses.FirstOrDefault(it => it.UserDisplayName == timesheet.UserName);
if (addr == null)
{
continue;
}
addr.UserEmail = timesheet.UserEmail;
addressesForUpdate.Add(addr);
}
notifiedUserList.Add(timesheet.UserName);
await connector.SendMessageAsync(
message,
new GoogleChatAddress(addr.SpaceName, string.Empty, "DM", addr.UserName, addr.UserDisplayName));
}
if (addressesForUpdate.Count > 0)
{
await _storageService.AddAddressesAsync(addressesForUpdate);
}
return(notifiedUserList);
}
