Merge pull request #154 from denis1011101/feature/court-street-in-picker

feat: tell namesake courts apart by street in the game form

Author: denis1011101

app/javascript/controllers/court_picker_controller.js

@@ -80,7 +80,8 @@ export default class extends Controller {
     this.selectTarget.innerHTML = ""
     groups.forEach(([cityName, cityCourts]) => {
       const parent = grouped && cityName ? this._appendGroup(cityName) : this.selectTarget
-      cityCourts.forEach(c => parent.appendChild(this._buildOption(String(c.id), c.name)))
+      const ambiguous = this._ambiguousNames(cityCourts)
+      cityCourts.forEach(c => parent.appendChild(this._buildOption(String(c.id), this._optionLabel(c, ambiguous))))
     })
 
     // Порядок опций задают группы, поэтому запасной вариант берём из самого списка.
@@ -139,6 +140,20 @@ export default class extends Controller {
       .map(([cityName, cityCourts]) => [cityName, cityCourts.sort((a, b) => a.name.localeCompare(b.name))])
   }
 
+  // Одноимённые площадки города различаем улицей: у остальных скобки — лишний шум.
+  _ambiguousNames(courts) {
+    const seen = new Set()
+    const duplicates = new Set()
+    courts.forEach(c => (seen.has(c.name) ? duplicates.add(c.name) : seen.add(c.name)))
+    return duplicates
+  }
+
+  _optionLabel(court, ambiguousNames) {
+    if (!court.street || !ambiguousNames.has(court.name)) return court.name
+
+    return `${court.name} (${court.street})`
+  }
+
   _appendGroup(label) {
     const group = document.createElement("optgroup")
     group.label = label

app/jobs/geocoding/fetch_court_address_job.rb

@@ -14,7 +14,10 @@ def perform(court_id, lat = nil, lng = nil)
     if result.is_a?(Hash) && result[:address].present?
       Rails.cache.write(cache_key, result[:address], expires_in: 1.day)
       court.update_column(:city_name, result[:city_name]) if result[:city_name].present?
-      Rails.logger.info "[Geocoding] cached address for Court##{court.id} -> #{result[:address]} (city: #{result[:city_name]})"
+      # Улицу храним в базе: адрес живёт только в кэше, а список кортов должен
+      # различать одноимённые площадки и без похода в геокодер.
+      court.update_column(:street, result[:street]) if result[:street].present?
+      Rails.logger.info "[Geocoding] cached address for Court##{court.id} -> #{result[:address]} (city: #{result[:city_name]}, street: #{result[:street]})"
     else
       Rails.logger.warn "[Geocoding] no address resolved for Court##{court.id}"
     end

app/services/geocoding/address_resolver.rb

@@ -13,7 +13,7 @@ class << self
     end
     self.nominatim_last_request_at = -Float::INFINITY
 
-    # Resolves lat/lng to { address: String, city_name: String | nil } or nil.
+    # Resolves lat/lng to { address: String, city_name: String | nil, street: String | nil } or nil.
     # Tries Google first, falls back to Nominatim.
     def resolve(lat, lng)
       geocode_google_full(lat, lng) || geocode_nominatim_structured(lat, lng)
@@ -55,7 +55,7 @@ def geocode_google_full(lat, lng)
       street_line = [ street, number ].compact.join(" ").presence
       address = [ street_line, city, country ].compact.join(", ").presence
 
-      { address: address, city_name: city }
+      { address: address, city_name: city, street: street_line }
     rescue => e
       Rails.logger.warn("Google geocoding error: #{e.message}")
       nil
@@ -113,7 +113,8 @@ def geocode_nominatim_structured(lat, lng)
 
       addr      = data["address"]
       city_name = addr && (addr["city"] || addr["town"] || addr["village"] || addr["municipality"])
-      { address: data["display_name"], city_name: city_name }
+      street    = addr && [ addr["road"], addr["house_number"] ].compact.join(" ").presence
+      { address: data["display_name"], city_name: city_name, street: street }
     rescue => e
       Rails.logger.warn("Nominatim error: #{e.message}")
       nil

app/views/games/_form.html.erb

@@ -211,8 +211,9 @@
          data-court-picker-default-lng-value="60.597465"
          data-court-picker-courts-value="<%= json_escape(sorted_courts.map { |c|
            lat, lng = c.coordinates.to_s.split(',').map(&:to_f)
-           { id: c.id, name: c.name, lat: lat, lng: lng, surfaces: c.surfaces, environments: c.environments,
-             city: c.city_name.to_s, country: locations[:city_country][c.city_name].to_s }
+           { id: c.id, name: c.name, street: c.street.to_s, lat: lat, lng: lng, surfaces: c.surfaces,
+             environments: c.environments, city: c.city_name.to_s,
+             country: locations[:city_country][c.city_name].to_s }
          }.to_json) %>"
          data-court-picker-country-cities-value="<%= json_escape(locations[:cities_by_country].to_json) %>"
          data-court-picker-city-placeholder-value="<%= t("games.form.court_city_any") %>"

db/migrate/20260822163931_add_street_to_courts.rb

@@ -0,0 +1,5 @@
+class AddStreetToCourts < ActiveRecord::Migration[8.1]
+  def change
+    add_column :courts, :street, :string
+  end
+end

db/schema.rb

@@ -18,4 +18,18 @@ namespace :geocoding do
 
     puts "Done. All jobs enqueued."
   end
+
+  desc "Backfill street for courts that have coordinates but no street"
+  task backfill_court_streets: :environment do
+    courts = Court.where(street: [ nil, "" ]).where.not(coordinates: [ nil, "" ])
+    total = courts.count
+    puts "Courts to backfill: #{total}"
+
+    courts.find_each.with_index do |court, i|
+      Geocoding::FetchCourtAddressJob.perform_later(court.id)
+      puts "  [#{i + 1}/#{total}] Enqueued Court##{court.id}"
+    end
+
+    puts "Done. All jobs enqueued."
+  end
 end

lib/tasks/geocoding.rake

@@ -601,6 +601,24 @@ class GamesControllerTest < ActionDispatch::IntegrationTest
     only&.destroy
   end
 
+  test "game form carries the street of every court so the picker can tell namesakes apart" do
+    greenwich = Court.create!(name: "Squash Territory", city_name: "Yekaterinburg", street: "8 Marta St 46",
+                              moderation_status: "approved")
+    elmash = Court.create!(name: "Squash Territory", city_name: "Yekaterinburg", street: "Kosmonavtov Ave 108",
+                           moderation_status: "approved")
+    post session_url, params: { email: "court-picker-street@example.com" }
+
+    get new_game_url
+
+    assert_response :success
+    courts = JSON.parse(css_select("[data-court-picker-courts-value]").first["data-court-picker-courts-value"])
+    streets = courts.select { |court| court["name"] == "Squash Territory" }.map { |court| court["street"] }
+    assert_equal [ "8 Marta St 46", "Kosmonavtov Ave 108" ], streets.sort
+  ensure
+    greenwich&.destroy
+    elmash&.destroy
+  end
+
   test "game form offers the comment field" do
     post session_url, params: { email: "comment_form_user@example.com" }
 

test/controllers/games_controller_test.rb

@@ -19,6 +19,28 @@ class Geocoding::FetchCourtAddressJobTest < ActiveSupport::TestCase
     end
   end
 
+  test "stores the street so the court list can tell namesakes apart" do
+    with_memory_cache do
+      with_stubbed_resolver({ address: "Tverskaya St 1, Moscow, Russia", city_name: "Moscow", street: "Tverskaya St 1" }) do
+        Geocoding::FetchCourtAddressJob.new.perform(@court.id)
+
+        assert_equal "Tverskaya St 1", @court.reload.street
+      end
+    end
+  end
+
+  test "keeps the stored street when the resolver has none" do
+    @court.update_columns(street: "Tverskaya St 1")
+
+    with_memory_cache do
+      with_stubbed_resolver({ address: "Somewhere, Moscow, Russia", city_name: "Moscow", street: nil }) do
+        Geocoding::FetchCourtAddressJob.new.perform(@court.id)
+
+        assert_equal "Tverskaya St 1", @court.reload.street
+      end
+    end
+  end
+
   test "does not write cache when resolver returns nil" do
     with_memory_cache do
       with_stubbed_resolver(nil) do

test/jobs/geocoding/fetch_court_address_job_test.rb

@@ -38,6 +38,7 @@ class Geocoding::AddressResolverTest < ActiveSupport::TestCase
         result = resolver.resolve(55.75, 37.62)
         assert_equal "Tverskaya St 1, Moscow, Russia", result[:address]
         assert_equal "Moscow", result[:city_name]
+        assert_equal "Tverskaya St 1", result[:street]
       end
     end
   end
@@ -49,14 +50,15 @@ class Geocoding::AddressResolverTest < ActiveSupport::TestCase
   test "resolve falls back to Nominatim when Google key is absent" do
     nominatim_payload = {
       "display_name" => "Tverskaya St, Moscow, Russia",
-      "address" => { "city" => "Moscow" }
+      "address" => { "city" => "Moscow", "road" => "Tverskaya St", "house_number" => "1" }
     }
 
     with_env("GOOGLE_GEOCODING_API_KEY" => "") do
       with_stubbed_fetch_json(nominatim_payload) do |resolver|
         result = resolver.resolve(55.75, 37.62)
         assert_equal "Tverskaya St, Moscow, Russia", result[:address]
         assert_equal "Moscow", result[:city_name]
+        assert_equal "Tverskaya St 1", result[:street]
       end
     end
   end