public void TestFromValidRadians()
{
const int runs = 10;
for (int i = 0; i < runs; ++i)
{
var radianLongitude = GenerateValidValue(GeographicalLocation.MAX_RADIAN_LONGITUDE);
var radianLatitude = GenerateValidValue(GeographicalLocation.MAX_RADIAN_LATITUDE);
var degreeLongitude = Calculator.DegreesToRadians(radianLongitude);
var degreeLatitude = Calculator.DegreesToRadians(radianLatitude);
var location = GeographicalLocation.FromRadians(radianLongitude, radianLatitude);
Assert.IsTrue(location.RadianLongitude == radianLongitude,
String.Format("Location radian longitude is not equal to the expected radian longitude! Expected: {0}, got: {1}.",
radianLongitude, location.RadianLongitude));
Assert.IsTrue(location.RadianLatitude == radianLatitude,
String.Format("Location radian latitude is not equal to the expected radian latitude! Expected: {0}, got: {1}.",
radianLatitude, location.RadianLatitude));
Assert.IsTrue(location.RadianLongitude == radianLongitude,
String.Format("Location radian longitude is not equal to the expected radian longitude! Expected: {0}, got: {1}.",
radianLongitude, location.RadianLongitude));
Assert.IsTrue(location.RadianLatitude == radianLatitude,
String.Format("Location radian latitude is not equal to the expected radian latitude! Expected: {0}, got: {1}.",
radianLatitude, location.RadianLatitude));
}
}
public void TestFromInvalidDegreeLatitude()
{
var degreeLongitude = GenerateValidValue(GeographicalLocation.MAX_DEGREE_LONGITUDE);
var degreeLatitude = GenerateInvalidValue(GeographicalLocation.MAX_DEGREE_LATITUDE);
var location = GeographicalLocation.FromDegrees(degreeLongitude, degreeLatitude);
}
public void TestFromInvalidRadianLatitude()
{
var radianLongitude = GenerateValidValue(GeographicalLocation.MAX_RADIAN_LONGITUDE);
var radianLatitude = GenerateInvalidValue(GeographicalLocation.MAX_RADIAN_LATITUDE);
var location = GeographicalLocation.FromRadians(radianLongitude, radianLatitude);
}
/// <summary>
/// Method used to parse a single JSON object and return customer data.
/// </summary>
/// <param name="match">Regex match.</param>
/// <returns>Customer data.</returns>
/// <exception cref="IntercomTestException">Thrown if the JSON object is not properly formatted.</exception>
private Customer ParseJsonObject(Match match)
{
if (ReferenceEquals(match, null))
{
throw new IntercomTestException("JSON text is in invalid format!");
}
var degreeLongitude = ReadDegreeLongitude(match);
if (!GeographicalLocation.IsDegreeLongitudeValid(degreeLongitude))
{
throw new IntercomTestException(String.Format("Invalid geographical longitude read: {0}!", degreeLongitude));
}
var degreeLatitude = ReadDegreeLatitude(match);
if (!GeographicalLocation.IsDegreeLatitudeValid(degreeLatitude))
{
throw new IntercomTestException(String.Format("Invalid geographical latitude read: {0}!", degreeLatitude));
}
var userId = ReadUserId(match);
var customerName = ReadCustomerName(match);
var location = GeographicalLocation.FromDegrees(degreeLongitude, degreeLatitude);
return(new Customer(userId, customerName, location));
}
public void TestLocationNull()
{
var userId = 0;
var name = "John Doe";
GeographicalLocation location = null;
var customer = new Customer(userId, name, location);
}
public void UpdateGeographicalLocation(GeographicalLocation geographicalLocation)
{
using (var db = new DataContext(_connectionString))
{
db.GeographicalLocations.Update(geographicalLocation);
db.SaveChanges();
}
}
public void TestCustomerNameEmpty()
{
var userId = 0;
var location = GeographicalLocation.FromDegrees(0.0d, 0.0d);
string name = string.Empty;
var customer = new Customer(userId, name, location);
}
public int AddGeographicalLocation(GeographicalLocation geographicalLocation)
{
using (var db = new DataContext(_connectionString))
{
db.GeographicalLocations.Add(geographicalLocation);
db.SaveChanges();
return(geographicalLocation.Id);
}
}
public void TestValidRadianLatitude()
{
double[] radianLatitudes = { -PI / 2, 00.0d, PI / 2, -PI * 0.32, PI / 4, -PI / 4, -PI * 0.426, PI * 0.001, PI * 0.499, -PI * 0.499, -PI / 3, PI / 3 };
foreach (var radianLatitude in radianLatitudes)
{
Assert.IsTrue(GeographicalLocation.IsRadianLatitudeValid(radianLatitude),
String.Format("Radian latitude {0} declared invalid, even though it is valid!", radianLatitude));
}
}
public void TestValidRadianLongitude()
{
double[] radianLongitudes = { -PI, PI, 0.0d, PI / 2, -PI / 2, -PI / 4, PI / 4, PI * 0.23, PI * 0.753, -PI * 0.3421, -PI * 0.6831, PI * 0.89123 };
foreach (var radianLongitude in radianLongitudes)
{
Assert.IsTrue(GeographicalLocation.IsRadianLongitudeValid(radianLongitude),
String.Format("Radian longitude {0} declared invalid, even though it is valid!", radianLongitude));
}
}
public void TestValidDegreeLatitude()
{
double[] degreeLatitudes = { -90.0d, 00.0d, 0.0d, -19.0d, -45.0d, 45.0d, 23.0d, 47.0d, -20.43d, 60.0d, -60.0d, 34.23d, -86.0d };
foreach (var degreeLatitude in degreeLatitudes)
{
Assert.IsTrue(GeographicalLocation.IsDegreeLatitudeValid(degreeLatitude),
String.Format("Degree latitude {0} declared invalid, even though it is valid!", degreeLatitude));
}
}
public void TestInvalidDegreeLatitude()
{
double[] degreeLatitudes = { -91.0d, 91.0d, 190.0d, -190.0d, 270.0, -270.0d, 360.0d, 360.0d, 200.0d, -300.0d };
foreach (var degreeLatitude in degreeLatitudes)
{
Assert.IsFalse(GeographicalLocation.IsDegreeLatitudeValid(degreeLatitude),
String.Format("Degree latitude {0} declared valid, even though it is invalid!", degreeLatitude));
}
}
public void TestInvalidRadianLatitude()
{
double[] radianLatitudes = { -PI - 0.001, PI + 0.001, PI * 0.52, -PI * 0.52, 3 * PI, -3 * PI, 2 * PI, -2 * PI, -3.232 * PI, 4.52 * PI };
foreach (var radianLatitude in radianLatitudes)
{
Assert.IsFalse(GeographicalLocation.IsRadianLatitudeValid(radianLatitude),
String.Format("Radian latitude {0} declared valid, even though it is invalid!", radianLatitude));
}
}
public Dictionary <int, double> CalculateTravelDistances(GeographicalLocation input, List <Suggestion> suggestions)
{
var dict = new Dictionary <int, double>();
for (int i = 0; i < suggestions.Count; i++)
{
dict[i] = CalculateDistanceWithHaversineDistanceFormula(input, suggestions.ElementAt(i));
}
return(dict);
}
public void AreCoordinatesValid_ShouldReturnFalse_ForNotValidCoordinates(double latitude, double longitude)
{
// Arrange
var coords = new GeographicalLocation(latitude, longitude);
//Act
var result = coords.AreCoordinatesValid();
//Assert
result.ShouldSatisfyAllConditions(
() => result.ShouldBeFalse()
);
}
public void AreCoordinatesValid_ShouldReturnTrue_ForValidCoordinates()
{
// Arrange
var coords = new GeographicalLocation(43.70011, -79.4163);
//Act
var result = coords.AreCoordinatesValid();
//Assert
result.ShouldSatisfyAllConditions(
() => result.ShouldBeTrue()
);
}
public void TestCustomerNameWhitespace()
{
const char whitespaceCharacter = ' ';
var userId = 0;
var location = GeographicalLocation.FromDegrees(0.0d, 0.0d);
var random = new Random(Environment.TickCount);
var numberOfWhitespaces = random.Next(1, 20);
var name = new string(whitespaceCharacter, numberOfWhitespaces);
var customer = new Customer(userId, name, location);
}
private double CalculateDistanceWithHaversineDistanceFormula(GeographicalLocation input, Suggestion suggestion, DistanceUnit unit = DistanceUnit.Kilometers)
{
double radius = (unit == DistanceUnit.Kilometers) ? EARTH_RADIUS_KM : EARTH_RADIUS_MILES;
var latitudeInRadians = (suggestion.Latitude.Value - input.Latitude.Value).ToRadians();
var longitudeInRadians = (suggestion.Longitude.Value - input.Longitude.Value).ToRadians();
var h1 = Math.Sin(latitudeInRadians / 2) * Math.Sin(latitudeInRadians / 2) +
Math.Cos(input.Latitude.Value.ToRadians()) * Math.Cos(suggestion.Latitude.Value.ToRadians()) *
Math.Sin(longitudeInRadians / 2) * Math.Sin(longitudeInRadians / 2);
var h2 = 2 * Math.Asin(Math.Min(1, Math.Sqrt(h1)));
return(radius * h2);
}
public void GeographicalLocation_ShouldInitializeProperly()
{
// Arrange
const double lat = 43.70011;
const double lon = -79.4163;
//Act
var coords = new GeographicalLocation(lat, lon);
//Assert
coords.ShouldSatisfyAllConditions(
() => coords.Latitude.ShouldBe(lat),
() => coords.Longitude.ShouldBe(lon)
);
}
public void TestCustomerValidInstantiation()
{
var userId = 0;
var name = "John Doe";
var location = GeographicalLocation.FromDegrees(0.0d, 0.0d);
var customer = new Customer(userId, name, location);
Assert.AreNotEqual(customer, null, "IntercomTest.Customer class has not been instantiated, even though all parameters are valid!");
Assert.AreEqual(customer.UserId, userId,
string.Format("IntercomTest.Customer class instance contains invalid data! Expected user ID: {0}, got {1}", userId, customer.UserId));
Assert.AreEqual(customer.Name, name.Trim(),
string.Format("IntercomTest.Customer class instance contains invalid data! Expected name: {0}, got {1}", name, customer.Name));
Assert.AreEqual(customer.Location, location, "IntercomTest.Customer class instance contains invalid data. Location references do not match.");
}
public IActionResult GetSuggestions(string q, double?latitude, double?longitude, int?n)
{
List <SuggestionDto> weightedResults;
var defaultResultSize = 10;
// Make sure q does not equal "", ", '', ' and empty
if (!q.IsValidInput())
{
return(BadRequest(new BadRequestError("The q paramter is mandatory")));
}
if (_trie.Trie.IsEmpty())
{
_seedDomainService.ResetPrefixTree();
}
if (n.HasValue && n >= 0)
{
defaultResultSize = n.Value;
}
var coords = new GeographicalLocation(latitude, longitude);
if (coords.Latitude.HasValue || coords.Longitude.HasValue)
{
if (!coords.AreCoordinatesValid())
{
return(BadRequest(new BadRequestError("Latitude and logitude are not proper format")));
}
}
//Fetch suggestions
var results = _trie.Trie.GetSuggestionsForPrefix(q.SanitizeInput()).ToList();
//Add score to values
if (coords.AreCoordinatesValid())
{
weightedResults = _scoringDomainService.WeightedSuggestionsWithCoordinates(results, defaultResultSize, coords);
}
else
{
weightedResults = _scoringDomainService.WeightedSuggestions(results, defaultResultSize);
}
return(Ok(weightedResults));
}
public void TestStaticCalculateDistance()
{
var fromDegreeLongitude = -6.257664d;
var fromDegreeLatitude = 53.339428d;
double[] toDegreeLongitudes = { -6.043701d, -10.27699d, -10.4240951d };
double[] toDegreeLatitudes = { 52.986375d, 51.92893d, 51.8856167d };
double[] expectedDistances = { 41.77d, 313.24d, 324.36d };
var fromLocation = GeographicalLocation.FromDegrees(fromDegreeLongitude, fromDegreeLatitude);
for (int i = 0; i < toDegreeLongitudes.Length; ++i)
{
var toLocation = GeographicalLocation.FromDegrees(toDegreeLongitudes[i], toDegreeLatitudes[i]);
var distance = GeographicalLocation.CalculateDistance(fromLocation, toLocation);
Assert.IsTrue(distance - expectedDistances[i] < DISTANCE_EPSILON,
string.Format("Wrong distance calculated! Expected: {0}, got: {1}.", expectedDistances[i], distance));
}
}
/// <summary>
/// Generates weighted scores for list of auto complete suggestions.
/// It takes into account the coordinates supplied in the query
/// </summary>
public List <SuggestionDto> WeightedSuggestionsWithCoordinates(List <Suggestion> suggestions, int maxValues, GeographicalLocation location)
{
var weightedSuggestions = new List <SuggestionDto>();
var maxPopularity = suggestions.Select(x => x.Popularity).DefaultIfEmpty(0).Max();
var distances = _travelDistanceScoreFactory.CalculateTravelDistances(location, suggestions);
var maximumDistance = distances.Values.Max();
for (var i = 0; i < suggestions.Count; i++)
{
var suggestion = suggestions.ElementAt(i);
suggestions.ElementAt(i).WeightedScore =
_popularityScoreFactory.ComputeLogarithmicPopularityScore(maxPopularity, suggestion.Popularity) +
_populationScoreFactory.ComputeLogarithmicPopulationScore(suggestion.Population) +
_editDistanceFactory.ComputeLogarithmicEditDistance(suggestion, true) +
_travelDistanceScoreFactory.CalculateDistanceScore(distances[i], maximumDistance);
weightedSuggestions.Add(_mapper.Map <SuggestionDto>(suggestion));
}
return(weightedSuggestions.OrderByDescending(q => q.Score).Take(maxValues).ToList());
}
static void Main(string[] args)
{
if (args.Length == 1)
{
if (string.IsNullOrWhiteSpace(args[0]))
{
PrintHelp();
}
Console.WriteLine();
Console.WriteLine("Closing the program. Press any key to continue...");
Console.ReadKey();
return;
}
if (args.Length > 1)
{
PrintHelp();
Console.WriteLine();
Console.WriteLine("Closing the program. Press any key to continue...");
Console.ReadKey();
return;
}
try
{
var dublinOfficeLocation = GeographicalLocation.FromDegrees(
ConfigurationReader.DublinOfficeDegreeLongitude, ConfigurationReader.DublinOfficeDegreeLatitude);
var reader = CreateReader();
var customers1 = reader.ReadCustomers();
var customers2 = customers1?.Where(customer => dublinOfficeLocation.DistanceFrom(customer.Location) < ConfigurationReader.InvitationDistanceKilometers);
var customers = customers2?.OrderBy(customer => customer.UserId);
if (ReferenceEquals(customers, null))
{
Console.WriteLine("An error has occurred! Customer info was note read.");
return;
}
Console.WriteLine("Customers to invite:");
foreach (var customer in customers)
{
Console.WriteLine("Name: {0}, user ID: {1}, distance: {2:0.00} km", customer.Name, customer.UserId,
customer.Location.DistanceFrom(dublinOfficeLocation));
}
}
catch (IntercomTestException ite)
{
Console.WriteLine(string.Format("An error has ocurred while trying to read user information! Detailed information: {0}",
ite.IntercomTestErrorMessage));
if (ite.HasInnerException)
{
Console.WriteLine("Inner exception: " + ite.InnerException.Message);
}
Console.WriteLine();
PrintHelp();
}
catch (ArgumentNullException ane)
{
Console.WriteLine("An internal erro has occurred!");
Console.WriteLine(ane.Message);
Console.WriteLine();
PrintHelp();
}
catch (ArgumentException ae)
{
Console.WriteLine("An internal erro has occurred!");
Console.WriteLine(ae.Message);
Console.WriteLine();
PrintHelp();
}
catch (DirectoryNotFoundException dnfe)
{
Console.WriteLine("Customer file directory not found!");
Console.WriteLine(dnfe.Message);
Console.WriteLine();
PrintHelp();
}
catch (FileNotFoundException fnfe)
{
Console.WriteLine("Customer file not found!");
Console.WriteLine(fnfe.Message);
Console.WriteLine();
PrintHelp();
}
catch (PathTooLongException ptle)
{
Console.WriteLine("Customer file path is too long!");
Console.WriteLine(ptle.Message);
Console.WriteLine();
PrintHelp();
}
catch (UnauthorizedAccessException uae)
{
Console.WriteLine("The current user does not have the perrmission to access the customer file" +
"or the operation is not supported beacuse the file is read-only!");
Console.WriteLine(uae.Message);
Console.WriteLine();
PrintHelp();
}
catch (NotSupportedException nse)
{
Console.WriteLine("Reading the customer file is not supported!. This may happen path is in invalid format.");
Console.WriteLine(nse.Message);
Console.WriteLine();
PrintHelp();
}
catch (SecurityException se)
{
Console.WriteLine("The current user does not have the perrmission to access the customer file!");
Console.WriteLine(se.Message);
Console.WriteLine();
PrintHelp();
}
finally
{
Console.WriteLine();
Console.WriteLine("Closing the program. Press any key to continue...");
Console.ReadKey();
}
}
