protected void btnSearch_Click(object sender, EventArgs e)
{
double radius = Convert.ToDouble(Radius.SelectedValue);
// These coordinates would normally be retrieved from a geocoding API such as Google's or Bing's.
// See https://github.com/scottschluer/Geocoder for an easy to use Geocoder API for Google.
Coordinate originCoordinate = new Coordinate { Latitude = 34.076234, Longitude = -118.395314 };
// Get the boundaries (min and max) latitude and longitude values. This forms a "square" around the origin coordinate
// with each leg of the square exactly "X" miles from the origin, where X is the selected radius.
CoordinateBoundaries boundaries = new CoordinateBoundaries(originCoordinate.Latitude, originCoordinate.Longitude, radius);
// Select from all of the locations
IEnumerable<Result> results = _locations
// Where the location's latitude is between the min and max latitude boundaries
.Where(x => x.Latitude >= boundaries.MinLatitude && x.Latitude <= boundaries.MaxLatitude)
// And where the location's longitude is between the min and max longitude boundaries
.Where(x => x.Longitude >= boundaries.MinLongitude && x.Longitude <= boundaries.MaxLongitude)
// Populate an instance of the Result class with the desired data, including distance/direction calculation
.Select(result => new Result
{
Name = result.Name,
Distance = GeoCalculator.GetDistance(originCoordinate.Latitude, originCoordinate.Longitude, result.Latitude, result.Longitude, 1),
Direction = GeoCalculator.GetDirection(originCoordinate.Latitude, originCoordinate.Longitude, result.Latitude, result.Longitude)
})
// Filter by distance. This is necessary because a radius is a circle, yet we've defined a square around the origin coordinate.
// This filter removes any extraneous results that would appear in the square's "corners" (imagine placing a circle inside a square of the
// same size for visualization).
.Where(x => x.Distance <= radius)
// Sort by distance
.OrderBy(x => x.Distance);
gvLocations.DataSource = results;
gvLocations.DataBind();
}
private IEnumerable <ResultModel> GetResults(Coordinate originCoordinate, double radius, DistanceUnit distanceUnit)
{
// Get the boundaries (min and max) latitude and longitude values. This forms a "square" around the origin coordinate
// with each leg of the square exactly "X" miles from the origin, where X is the selected radius.
var boundaries = new CoordinateBoundaries(originCoordinate.Latitude, originCoordinate.Longitude, radius, distanceUnit);
// Select from all of the locations
return(Locations
// Where the location's latitude is between the min and max latitude boundaries
.Where(x => x.Latitude >= boundaries.MinLatitude && x.Latitude <= boundaries.MaxLatitude)
// And where the location's longitude is between the min and max longitude boundaries
.Where(x => x.Longitude >= boundaries.MinLongitude && x.Longitude <= boundaries.MaxLongitude)
// Populate an instance of the Result class with the desired data, including distance/direction calculation
.Select(result => new ResultModel
{
Name = result.Name,
Distance = GeoCalculator.GetDistance(originCoordinate.Latitude, originCoordinate.Longitude, result.Latitude, result.Longitude, distanceUnit: distanceUnit),
Direction = GeoCalculator.GetDirection(originCoordinate.Latitude, originCoordinate.Longitude, result.Latitude, result.Longitude)
})
// Filter by distance. This is necessary because a radius is a circle, yet we've defined a square around the origin coordinate.
// This filter removes any extraneous results that would appear in the square's "corners" (imagine placing a circle inside a square of the
// same size for visualization).
.Where(x => x.Distance <= radius)
// Sort by distance
.OrderBy(x => x.Distance));
}
public override Task <AssaultCommand> InPosition(Position position, ServerCallContext context)
{
var boundaries = new CoordinateBoundaries(
position.Latitude,
position.Longitude,
15.2,
DistanceUnit.Kilometers);
var unavailableBoundaries = new CoordinateBoundaries(
position.Latitude,
position.Longitude,
4.2,
DistanceUnit.Kilometers);
return(InPositionFaultPolicy.ExecuteAsync(
() => Task.FromResult(new AssaultCommand
{
Position = new Position
{
Latitude = _faker.Random.Double(unavailableBoundaries.MaxLatitude, boundaries.MaxLatitude),
Longitude = _faker.Random.Double(unavailableBoundaries.MaxLongitude, boundaries.MaxLongitude)
},
DirectionDeviation = Math.Round(_faker.Random.Double(0, 360), 2)
})));
}
public async Task <ObjectResult> GetSuggestions()
{
string userId = sessionService.GetCurrentUserId();
ApplicationUser user = await userRepository.GetUserAccount(userId);
CoordinateBoundaries boundaries = new CoordinateBoundaries(user.Lat, user.Lon, user.MatchRadius, DistanceUnit.Kilometers);
IEnumerable <ApplicationUser> matchesInRadius = await suggestionsRepository.GetUsersInMatchRadius(boundaries.MinLatitude, boundaries.MaxLatitude, boundaries.MinLongitude, boundaries.MaxLongitude);
IEnumerable <string> previouslyRespondedSuggestionsIds = suggestionsRepository.GetPreviousSuggestions(userId);
IEnumerable <ReturnedUser> suggestedUsers = matchesInRadius.Select(x => new ReturnedUser
{
Id = x.Id,
Username = x.UserName,
Name = x.Name != null && x.Name.Length != 0 ? x.Name : x.UserName,
Picture = x.Picture,
Bio = x.Bio,
LookingFor = x.LookingFor,
Genres = x.Genres.Select(ug => ug.Genre.Name).ToArray(),
Venues = x.Venues.Select(uv => uv.Venue.Name).ToArray(),
Distance = GeoCalculator.GetDistance(user.Lat, user.Lon, x.Lat, x.Lon)
}).ToList()
.Where(x => x.Id != user.Id)
.Where(x => !previouslyRespondedSuggestionsIds.Contains(x.Id))
.Where(x => x.Distance <= user.MatchRadius)
.OrderBy(x => x.Distance);
foreach (ReturnedUser u in suggestedUsers)
{
u.Role = await userRepository.GetAcountRole(u.Id);
}
return(Ok(suggestedUsers));
}
public void CalculateThrowsArgumentExceptionWithInvalidLatitudeProperty()
{
CoordinateBoundaries boundaries = new CoordinateBoundaries();
var ex = Assert.Throws<ArgumentException>(() => boundaries.Latitude = Constants.Coordinates.LatitudeBelowMinimum.Latitude);
Assert.AreEqual(ex.Message, "Invalid coordinates supplied.");
}
public void CalculateThrowsArgumentExceptionWithInvalidLongitudeProperty()
{
CoordinateBoundaries boundaries = new CoordinateBoundaries();
var ex = Assert.Throws <ArgumentException>(() => boundaries.Longitude = Constants.Coordinates.LongitudeBelowMinumum.Longitude);
Assert.AreEqual(ex.Message, "Invalid coordinates supplied.");
}
public List <ApplicationUser> GetBeneficiariesInRange(List <ApplicationUser> beneficiaries, ApplicationUser volunteer, int radiusInKm)
{
CoordinateBoundaries boundaries = new CoordinateBoundaries(volunteer.Latitude, volunteer.Longitude, radiusInKm, DistanceUnit.Meters);
return(beneficiaries
.Where(b => b.Latitude >= boundaries.MinLatitude && b.Latitude <= boundaries.MaxLatitude)
.Where(b => b.Longitude >= boundaries.MinLongitude && b.Longitude <= boundaries.MaxLongitude)
.AsEnumerable()
.Where(b => IsInRange(volunteer, b)).ToList());
}
public IEnumerable <ApplicationUser> GetVolunteersInRange(IQueryable <ApplicationUser> volunteers, ApplicationUser beneficiary, int radiusInKm)
{
CoordinateBoundaries boundaries = new CoordinateBoundaries(beneficiary.Latitude, beneficiary.Longitude, radiusInKm, DistanceUnit.Kilometers);
return(volunteers
.Where(v => v.Latitude >= boundaries.MinLatitude && v.Latitude <= boundaries.MaxLatitude)
.Where(v => v.Longitude >= boundaries.MinLongitude && v.Longitude <= boundaries.MaxLongitude)
.AsEnumerable()
.Where(v => IsInRange(v, beneficiary)));
}
public void CalculateReturnsCorrectMaximumLongitude()
{
Coordinate origin = Constants.Coordinates.ValidCoordinate;
int radius = 25;
CoordinateBoundaries boundaries = new CoordinateBoundaries(origin.Latitude, origin.Longitude, radius);
double expectedResult = -117.9603252732495;
Assert.AreEqual(boundaries.MaxLongitude, expectedResult);
}
public void CalculateReturnsCorrectMinimumLongitude()
{
Coordinate origin = Constants.Coordinates.ValidCoordinate;
int radius = 25;
CoordinateBoundaries boundaries = new CoordinateBoundaries(origin.Latitude, origin.Longitude, radius);
double expectedResult = -118.83509292675051;
Assert.AreEqual(boundaries.MinLongitude, expectedResult);
}
public void CalculateWithCoordinateObjectReturnsCorrectMaximumLatitude()
{
Coordinate origin = Constants.Coordinates.ValidCoordinate;
int radius = 25;
CoordinateBoundaries boundaries = new CoordinateBoundaries(origin, radius);
double expectedResult = 34.429910640579713;
Assert.AreEqual(boundaries.MaxLatitude, expectedResult);
}
public void CalculateReturnsCorrectMinimumLongitude()
{
Coordinate origin = Constants.Coordinates.ValidCoordinate;
int radius = 25;
CoordinateBoundaries boundaries = new CoordinateBoundaries(origin.Latitude, origin.Longitude, radius);
double expectedResult = -118.83509292675051;
Assert.AreEqual(boundaries.MinLongitude, expectedResult);
}
public void CalculateReturnsCorrectMaximumLongitude()
{
Coordinate origin = Constants.Coordinates.ValidCoordinate;
int radius = 25;
CoordinateBoundaries boundaries = new CoordinateBoundaries(origin.Latitude, origin.Longitude, radius);
double expectedResult = -117.9603252732495;
Assert.AreEqual(boundaries.MaxLongitude, expectedResult);
}
public void CalculateWithCoordinateObjectReturnsCorrectMinimumLatitude()
{
Coordinate origin = Constants.Coordinates.ValidCoordinate;
int radius = 25;
CoordinateBoundaries boundaries = new CoordinateBoundaries(origin, radius);
double expectedResult = 33.705272959420292;
Assert.AreEqual(boundaries.MinLatitude, expectedResult);
}
public void GetMaxLatitudeFromBearing_GivenCoordinates_expectCorrectLongitude()
{
Coordinate coordinate = new Coordinate(51.647611, 5.050500);
CoordinateBoundaries boundaries = new CoordinateBoundaries(coordinate, 2.0, DistanceUnit.Meters);
Assert.Equal(51.647629010716372, CoordinateExtensions.GetMaxLatitudeFromBearing(boundaries, 2));
Assert.Equal(51.647592989283623, CoordinateExtensions.GetMaxLatitudeFromBearing(boundaries, 91));
Assert.Equal(51.647629010716372, CoordinateExtensions.GetMaxLatitudeFromBearing(boundaries, 271));
Assert.Equal(51.647592989283623, CoordinateExtensions.GetMaxLatitudeFromBearing(boundaries, 269));
Assert.Equal(51.647592989283623, CoordinateExtensions.GetMaxLatitudeFromBearing(boundaries, 180));
}
public void CalculateReturnsCorrectMaximumLatitudeWithMetres()
{
// Arrange
var origin = new Coordinate() { Latitude = 53.401556, Longitude = -2.978207 };
int distance = 100;
// Act
var boundaries = new CoordinateBoundaries(origin, distance, DistanceUnit.Metres);
// Assert
double expectedResult = 53.402456535818814;
Assert.AreEqual(boundaries.MaxLatitude, expectedResult);
}
private async Task <LocationResult> GetByLocation(Classes.Models.Location.Location location, int radius)
{
var boundaries = new CoordinateBoundaries(location.Lat, location.Lng, radius);
var client = new HttpClient();
var query = await client.GetAsync($"https://query.displaypurposes.com/local/?bbox={boundaries.MinLongitude},{boundaries.MinLatitude},{boundaries.MaxLongitude},{boundaries.MaxLatitude}&zoom=10")
.ConfigureAwait(false);
var text = await query.Content.ReadAsStringAsync().ConfigureAwait(false);
var results = SerializationHelper.DeserializeFromString <LocationResult>(text);
return(results);
}
public void GetMaxLongitudeFromBearing_GivenCoordinates_expectCorrectLongitude()
{
Coordinate coordinate = new Coordinate(51.647611, 5.050500);
CoordinateBoundaries boundaries = new CoordinateBoundaries(coordinate, 2.0, DistanceUnit.Meters);
Assert.Equal(5.0505290263055267, CoordinateExtensions.GetMaxLongitudeFromBearing(boundaries, 2));
Assert.Equal(5.0505290263055267, CoordinateExtensions.GetMaxLongitudeFromBearing(boundaries, 91));
Assert.Equal(5.0505290263055267, CoordinateExtensions.GetMaxLongitudeFromBearing(boundaries, 179));
Assert.Equal(5.0505290263055267, CoordinateExtensions.GetMaxLongitudeFromBearing(boundaries, 180));
Assert.Equal(5.0504709736944742, CoordinateExtensions.GetMaxLongitudeFromBearing(boundaries, 181));
Assert.Equal(5.0504709736944742, CoordinateExtensions.GetMaxLongitudeFromBearing(boundaries, 279));
Assert.Equal(5.0504709736944742, CoordinateExtensions.GetMaxLongitudeFromBearing(boundaries, 360));
Assert.Equal(5.0505290263055267, CoordinateExtensions.GetMaxLongitudeFromBearing(boundaries, 0));
}
private Location GetRandomLocation()
{
var boundaries = new CoordinateBoundaries(_center.Latitude, _center.Longitude, _radiusInMeters, DistanceUnit.Meters);
double minLatitude = boundaries.MinLatitude;
double maxLatitude = boundaries.MaxLatitude;
double minLongitude = boundaries.MinLongitude;
double maxLongitude = boundaries.MaxLongitude;
var random = new Random();
var latitude = random.NextDouble() * (maxLatitude - minLatitude) + maxLatitude;
var longitude = random.NextDouble() * (maxLongitude - minLongitude) + maxLongitude;
return(new Location(longitude, latitude));
}
public async Task <Portal[]> GetPortals(double radius, Location location = default, CancellationToken cancellationToken = default)
{
location = location ?? myDefaultLocation;
var boundaries = new CoordinateBoundaries(location.Latitude, location.Longitude, radius, DistanceUnit.Kilometers);
var queryBuilder = new QueryBuilder
{
{ "nelat", boundaries.MaxLatitude.ToString(CultureInfo.InvariantCulture) },
{ "nelng", boundaries.MaxLongitude.ToString(CultureInfo.InvariantCulture) },
{ "swlat", boundaries.MinLatitude.ToString(CultureInfo.InvariantCulture) },
{ "swlng", boundaries.MinLongitude.ToString(CultureInfo.InvariantCulture) },
{ "offset", 0.ToString() },
{ "telegram", "" }
};
return(await Execute("getPortals.php", queryBuilder, cancellationToken, "portalData"));
}
public void CalculateReturnsCorrectMaximumLatitudeWithMetres()
{
// Arrange
var origin = new Coordinate()
{
Latitude = 53.401556, Longitude = -2.978207
};
int distance = 100;
// Act
var boundaries = new CoordinateBoundaries(origin, distance, DistanceUnit.Metres);
// Assert
double expectedResult = 53.402456535818814;
Assert.AreEqual(boundaries.MaxLatitude, expectedResult);
}
private static List <Restaurant> SearchResturantsWithInSpecifiedMiles(RedisList <Restaurant> restaurants, int miles)
{
var boundaries = new CoordinateBoundaries(Latitude, Longitude, miles);
var filteredRestaurants = new List <Restaurant>();
Parallel.ForEach(restaurants, (restaurant) => {
if ((restaurant.ResturantGeo.Latitude >= boundaries.Latitude &&
restaurant.ResturantGeo.Latitude <= boundaries.Latitude) &&
(restaurant.ResturantGeo.Longitude >= boundaries.Longitude &&
restaurant.ResturantGeo.Longitude <= boundaries.Longitude))
{
filteredRestaurants.Add(restaurant);
}
});
return(filteredRestaurants);
}
public static Coordinate GetStepCoordinates(Coordinate from, Coordinate to, double distance)
{
var bearing = GeoCalculator.GetBearing(from, to);
var angle = GetRelativeBearingToClosestDirection(bearing);
var(latitudeFactor, longitudeFactor) = CorrectionFactors(angle, bearing);
var boundaries = new CoordinateBoundaries(from, distance, DistanceUnit.Meters);
var maxLongitude = GetMaxLongitudeFromBearing(boundaries, bearing);
var maxLatitude = GetMaxLatitudeFromBearing(boundaries, bearing);
var newLongitude = from.Longitude + (maxLongitude - from.Longitude) * longitudeFactor;
var newLatitude = from.Latitude + (maxLatitude - from.Latitude) * latitudeFactor;
return(new Coordinate(newLatitude, newLongitude));
}
/// <summary>
/// Returns a <see cref="System.String"/> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="System.String"/> that represents this instance.
/// </returns>
public override string ToString()
{
var retVal = string.Format("{0},{1},{2},{3}", MinLongitude, MinLatitude, MaxLongitude, MaxLatitude);
if (UseCoordinates)
{
var boundaries = new CoordinateBoundaries(Latitude, Longitude, 0.25);
// -122.75,36.8,-121.75,37.8
double minLatitude = boundaries.MinLatitude;
double maxLatitude = boundaries.MaxLatitude;
double minLongitude = boundaries.MinLongitude;
double maxLongitude = boundaries.MaxLongitude;
//var retVal = string.Format("{0},{1},{2},{3}", minLatitude, maxLongitude, maxLatitude, minLongitude);
//var retVal = string.Format("{0},{1},{2},{3}", minLatitude, minLongitude, maxLatitude, maxLongitude);
retVal = string.Format("{0},{1},{2},{3}", minLongitude, minLatitude, maxLongitude, maxLatitude);
}
return retVal;
}
public async Task <ActionResult> GetBusinessforCustomer(BusinessForClientViewmodel businessForClientViewmodel)
{
var totalFeedBack = 0.0;
var response = await context.Businesses.Include(bt => bt.businessType).Include(f => f.FeedBacks).Where(iv => iv.isVisible).AsNoTracking().ToListAsync();
for (int i = 0; i < response.Count; i++)
{
if (response[i].FeedBacks.Count > 0)
{
for (int j = 0; j < response[i].FeedBacks.Count; j++)
{
if (response[i].FeedBacks[j].OverallRating.HasValue)
{
totalFeedBack += response[i].FeedBacks[j].OverallRating.Value;
}
}
response[i].OverallRating = totalFeedBack / double.Parse(response[i].FeedBacks.Count.ToString());
}
}
Coordinate origin = new Coordinate(businessForClientViewmodel.UserLatitude, businessForClientViewmodel.UserLongitude);
CoordinateBoundaries boundaries = new CoordinateBoundaries(origin, 10);
double minLatitude = boundaries.MinLatitude;
double maxLatitude = boundaries.MaxLatitude;
double minLongitude = boundaries.MinLongitude;
double maxLongitude = boundaries.MaxLongitude;
var results = response
.Where(x => x.Latitude >= minLatitude && x.Latitude <= maxLatitude)
.Where(x => x.Longitude >= minLongitude && x.Longitude <= maxLongitude)
.Select(result => new
{
Store = result,
Distance = GeoCalculator.GetDistance(origin.Latitude, origin.Longitude, result.Latitude, result.Longitude, 1),
Direction = GeoCalculator.GetDirection(origin.Latitude, origin.Longitude, result.Latitude, result.Longitude)
})
.Where(x => x.Distance <= 10)
.OrderBy(x => x.Distance)
.ToList();
response = results.Select(x => x.Store).ToList();
return(new OkObjectResult(response));
}
public override Task <RePositionCommand> RegisterUnit(RegisterArtilleryUnitRequest request, ServerCallContext context)
{
return(RegistrationLatency.ExecuteAsync(() =>
{
var boundaries = new CoordinateBoundaries(
request.Position.Latitude,
request.Position.Longitude,
60,
DistanceUnit.Kilometers);
return Task.FromResult(new RePositionCommand
{
Position = new Position
{
Latitude = _faker.Random.Double(boundaries.MinLatitude, boundaries.MaxLatitude),
Longitude = _faker.Random.Double(boundaries.MinLongitude, boundaries.MaxLongitude)
},
MainFiringDirection = Math.Round(_faker.Random.Double(0, 360), 2)
});
}));
}
public IEnumerable <Book> SearchBooks(string regexString, List <CategoryOfBook> categoriesOfBook, double longitude, double latitude, double radius)
{
CoordinateBoundaries boundaries = new CoordinateBoundaries(latitude, longitude, radius, DistanceUnit.Kilometers);
Regex regex;
if
(regexString == "")
{
regex = new Regex("^.*$");
}
else
{
regex = new Regex($"^.*{regexString}.*$", RegexOptions.IgnoreCase);
}
return(_context.Books
.Where(x => x.Latitude >= boundaries.MinLatitude && x.Latitude <= boundaries.MaxLatitude)
.Where(x => x.Longitude >= boundaries.MinLongitude && x.Longitude <= boundaries.MaxLongitude)
.Where(x => categoriesOfBook.Contains(x.Category))
.Include(p => p.Owner)
.ToList()
.FindAll(x => regex.IsMatch(x.Title)));
}
protected void btnSearch_Click(object sender, EventArgs e)
{
double radius = Convert.ToDouble(Radius.SelectedValue);
// These coordinates would normally be retrieved from a geocoding API such as Google's or Bing's.
// See https://github.com/scottschluer/Geocoder for an easy to use Geocoder API for Google.
Coordinate originCoordinate = new Coordinate {
Latitude = 34.076234, Longitude = -118.395314
};
// Get the boundaries (min and max) latitude and longitude values. This forms a "square" around the origin coordinate
// with each leg of the square exactly "X" miles from the origin, where X is the selected radius.
CoordinateBoundaries boundaries = new CoordinateBoundaries(originCoordinate.Latitude, originCoordinate.Longitude, radius);
// Select from all of the locations
IEnumerable <Result> results = _locations
// Where the location's latitude is between the min and max latitude boundaries
.Where(x => x.Latitude >= boundaries.MinLatitude && x.Latitude <= boundaries.MaxLatitude)
// And where the location's longitude is between the min and max longitude boundaries
.Where(x => x.Longitude >= boundaries.MinLongitude && x.Longitude <= boundaries.MaxLongitude)
// Populate an instance of the Result class with the desired data, including distance/direction calculation
.Select(result => new Result
{
Name = result.Name,
Distance = GeoCalculator.GetDistance(originCoordinate.Latitude, originCoordinate.Longitude, result.Latitude, result.Longitude, 1),
Direction = GeoCalculator.GetDirection(originCoordinate.Latitude, originCoordinate.Longitude, result.Latitude, result.Longitude)
})
// Filter by distance. This is necessary because a radius is a circle, yet we've defined a square around the origin coordinate.
// This filter removes any extraneous results that would appear in the square's "corners" (imagine placing a circle inside a square of the
// same size for visualization).
.Where(x => x.Distance <= radius)
// Sort by distance
.OrderBy(x => x.Distance);
gvLocations.DataSource = results;
gvLocations.DataBind();
}
public void CalculateWithCoordinateObjectReturnsCorrectMaximumLatitude()
{
Coordinate origin = Constants.Coordinates.ValidCoordinate;
int radius = 25;
CoordinateBoundaries boundaries = new CoordinateBoundaries(origin, radius);
double expectedResult = 34.429910640579713;
Assert.AreEqual(boundaries.MaxLatitude, expectedResult);
}
public static double GetMaxLongitudeFromBearing(CoordinateBoundaries boundary, double bearing)
{
return(bearing <= 180 ? boundary.MaxLongitude : boundary.MinLongitude);
}
public static double GetMaxLatitudeFromBearing(CoordinateBoundaries boundary, double bearing)
{
return(bearing >= 90 && bearing < 270 ? boundary.MinLatitude : boundary.MaxLatitude);
}
public async Task Assault(
double targetLatitude,
double targetLongitude,
double directionDeviation,
[Option(ShortName = "t")] TimeoutPolicyKey timeoutPolicyKey = TimeoutPolicyKey.NoTimeout,
[Option(ShortName = "c")] TimeoutPolicyKey correctionTimeoutPolicyKey = TimeoutPolicyKey.NoTimeout)
{
var(horizontal, vertical) = GetAngles(targetLatitude, targetLongitude, directionDeviation);
await _battery.Aim(horizontal, vertical, timeoutPolicyKey);
await _battery.Fire(40, timeoutPolicyKey);
var correctionTimeoutPolicy = _policyRegistry.Get <IAsyncPolicy>(correctionTimeoutPolicyKey.ToString());
var correctionFallbackPolicy = Policy
.Handle <RpcException>()
.Or <TimeoutRejectedException>()
.FallbackAsync(
async token =>
{
var coordBoundaries = new CoordinateBoundaries(_battery.Latitude, _battery.Longitude, 2,
DistanceUnit.Kilometers);
_battery.RePosition(
_faker.Random.Double(coordBoundaries.MinLatitude, coordBoundaries.MaxLatitude),
_faker.Random.Double(coordBoundaries.MinLongitude, coordBoundaries.MaxLongitude)
);
var assaultCommand = await _client.InPositionAsync(new Position
{
Latitude = _battery.Latitude,
Longitude = _battery.Longitude
}, deadline: DateTime.UtcNow.AddMilliseconds(1000));
_console.Out.WriteLine(
$"Assault command received. Target: lat: {assaultCommand.Position.Latitude}; lon:{assaultCommand.Position.Longitude}" +
$" direction: {assaultCommand.DirectionDeviation};");
},
async exception =>
{
_console.Out.WriteLine($"Could not get correction, falling back to new position. Exception: {exception.Message}");
await Task.CompletedTask;
});
var lastResortPolicy = Policy
.Handle <RpcException>()
.Or <TimeoutRejectedException>()
.FallbackAsync(token => _battery.Disengage());
var policyWrap = Policy.WrapAsync(lastResortPolicy, correctionFallbackPolicy, correctionTimeoutPolicy);
await policyWrap.ExecuteAsync(async token =>
{
var correction = await _client.GetCorrectionAsync(
new Position
{
Latitude = _battery.Latitude,
Longitude = _battery.Longitude
},
cancellationToken: token);
token.ThrowIfCancellationRequested();
_console.Out.WriteLine(
$"Assault command correction received. Target: lat: {correction.Position.Latitude}; lon:{correction.Position.Longitude}" +
$" direction: {correction.DirectionDeviation};");
},
CancellationToken.None);
}
public void CalculateWithCoordinateObjectReturnsCorrectMinimumLatitude()
{
Coordinate origin = Constants.Coordinates.ValidCoordinate;
int radius = 25;
CoordinateBoundaries boundaries = new CoordinateBoundaries(origin, radius);
double expectedResult = 33.705272959420292;
Assert.AreEqual(boundaries.MinLatitude, expectedResult);
}
