Geocoding Fix: Accurate Country Data With Existing Tools

The Problem: Inaccurate Country Assignments

The core issue lies in how our system currently handles geographical data. The current implementation of CityResolver is discarding the crucial country_code that the :geocoding library provides. This results in the system relying on error-prone address pattern matching. Specifically, the system defaults to the United Kingdom, leading to incorrect assignments for venues, especially in Ireland. This phase 2 fix addresses this inaccuracy by leveraging the information already available within our existing tools.

Imagine you're trying to find events in a specific country. If the system incorrectly identifies the country, you'll miss out on relevant events. This directly impacts user experience and data accuracy. The existing system’s reliance on pattern matching isn't just inaccurate; it's a bottleneck, preventing the system from correctly identifying locations and, in turn, providing users with the information they need.

To solve this problem, we need to correct the origin of the information. Using the correct information will help users find the correct events. The current system causes some problems, such as a large number of searches. Users have to spend a lot of time searching for the correct information. The best way to solve this is to follow the steps in this article.

The Solution: Utilize Geocoding and Existing Libraries

The solution is straightforward: utilize the country code from the :geocoding library. We already have the necessary tools; we just need to use them correctly. The :geocoding library, coupled with the Countries library, provides accurate country information. By implementing these, the system will accurately assign countries to venues.

This approach eliminates the need for the error-prone address pattern matching and UK defaults. Instead, the system will be able to pinpoint the correct country more reliably. This results in improved data accuracy and a better user experience. By implementing the solution correctly, we can also improve SEO and data organization.

Step 1: Implementing resolve_city_and_country/2

First, we need to add the function resolve_city_and_country/2 to the CityResolver. This function will take latitude and longitude coordinates as input and return both the city name and the corresponding country code. This function uses the :geocoding library to retrieve this data. The core of this function involves the following steps: Using the :geocoding.reverse() function to get the city and country code from GPS coordinates. The function handles potential errors, such as a missing location, gracefully.

@doc """
Resolves both city name and country code from GPS coordinates.
Returns ISO 2-letter country code as provided by the geocoding library.
"""
@spec resolve_city_and_country(float() | nil, float() | nil) :==
{:ok, {String.t(), String.t()}} | {:error, atom()}
def resolve_city_and_country(latitude, longitude)
 when is_float(latitude) and is_float(longitude) do
 try do
 case :geocoding.reverse(latitude, longitude) do
 {:ok, {_continent, country_code, city_binary, _distance}} ->
 city_name = to_string(city_binary)
 country = to_string(country_code)

 case validate_city_name(city_name) do
 {:ok, validated_name} ->
 {:ok, {validated_name, country}}
 {:error, _reason} ->
 {:error, :invalid_city_name}
 end

 {:error, _reason} ->
 {:error, :not_found}
 end
 rescue
 _ -> {:error, :geocoding_error}
 end
end

Step 2: Use the Countries Library

Next, the Countries library is utilized to convert the ISO country code into a full country name. This involves creating a helper function, country_name_from_code/1, which takes the ISO code and returns the full country name. The code uses the Countries.get function and handles cases where the code doesn’t exist.

# In transformer.ex - simple helper
defp country_name_from_code(code) when is_binary(code) do
 case Countries.get(String.upcase(code)) do
 nil -> nil
 country -> country.name
 end
end

defp country_name_from_code(_), do: nil

This step ensures that the system displays user-friendly country names instead of abbreviated codes, improving the user experience. The example below shows how to use this helper function.

case CityResolver.resolve_city_and_country(lat, lng) do
 {:ok, {city, country_code}} ->
 country_name = country_name_from_code(country_code)
 # "IE" -> "Ireland"
 # "GB" -> "United Kingdom"
 {city, country_name || "Unknown"}

 {:error, _} ->
 # Fallback to existing logic
end

Step 3: Eliminating detect_country_from_address

The final step involves deleting the detect_country_from_address function. This function relied on pattern matching, which caused the UK default bug. Removing this function removes the source of the errors. By eliminating this function, we ensure that the system relies solely on the reliable data from the :geocoding library and the Countries library.

Libraries and Files to Modify

This implementation leverages existing libraries and requires modifications to several files. These libraries are already in use. The following table provides an overview.

The following files need modifications.

1. lib/eventasaurus_discovery/helpers/city_resolver.ex
   • Add resolve_city_and_country/2 function.
   • Keep existing resolve_city/2 for backward compatibility.
2. lib/eventasaurus_discovery/sources/speed_quizzing/transformer.ex
   • Update resolve_location/3 to use the new function.
   • Add country_name_from_code/1 helper.
   • Delete detect_country_from_address/1.
3. Other scrapers (audit and update as needed):
   • resident_advisor/transformer.ex
   • bandsintown/transformer.ex
   • inquizition/transformer.ex
   • geeks_who_drink/transformer.ex
   • ticketmaster/transformer.ex
   • quizmeisters/transformer.ex
   • cinema_city/transformer.ex

Testing and Validation

Thorough testing is crucial to ensure that the changes work as expected. The testing phase involves verifying the functionality of the new implementation using specific coordinates. The goal is to confirm that the system correctly identifies and assigns countries.

# Test Irish coordinates
{:ok, {city, country}} = CityResolver.resolve_city_and_country(51.8985, -8.4756)
assert city == "Cork"
assert country == "IE"
assert country_name_from_code(country) == "Ireland"

# Test UK coordinates
{:ok, {city, country}} = CityResolver.resolve_city_and_country(51.5074, -0.1278)
assert city == "London"
assert country == "GB"
assert country_name_from_code(country) == "United Kingdom"

The test cases cover Irish and UK coordinates. The assert statements confirm that the system returns the correct city and country names. The tests demonstrate the fix in action, ensuring that venues are correctly assigned to their respective countries.

What Not to Do

To ensure the effectiveness and maintainability of the solution, there are several practices to avoid.

• ❌ No regex pattern matching for postcodes/Eircodes.
• ❌ No hardcoded city names.
• ❌ No country detection from address strings.
• ❌ No UK defaults.

Conclusion

By implementing these steps, we can significantly improve the accuracy of country assignments within our system. This will lead to a better user experience and more reliable data. Leveraging the existing :geocoding and Countries libraries allows us to avoid error-prone methods and provides a robust solution.

For more information on geocoding and country data, check out the Geonames website.