Store distance in meters in the database and convert to user's preferred unit on the fly.

CHANGELOG.md

@@ -17,6 +17,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Don't check for new version in production.
 - Area popup styles are now more consistent.
 - Notification about Photon API load is now disabled.
+- All distance values are now stored in the database in meters. Conversion to user's preferred unit is done on the fly.
 
 ## Fixed
 

app/controllers/map_controller.rb

@@ -35,22 +35,16 @@ class MapController < ApplicationController
   end
 
   def calculate_distance
-    distance = 0
+    total_distance_meters = 0
 
     @coordinates.each_cons(2) do
-      distance += Geocoder::Calculations.distance_between(
-        [_1[0], _1[1]], [_2[0], _2[1]], units: current_user.safe_settings.distance_unit.to_sym
+      distance_km = Geocoder::Calculations.distance_between(
+        [_1[0], _1[1]], [_2[0], _2[1]], units: :km
       )
+      total_distance_meters += distance_km * 1000 # Convert km to meters
     end
 
-    distance_in_meters = case current_user.safe_settings.distance_unit.to_s
-                         when 'mi'
-                           distance * 1609.344 # miles to meters
-                         else
-                           distance * 1000 # km to meters
-                         end
-
-    distance_in_meters.round
+    total_distance_meters.round
   end
 
   def parsed_start_at

app/helpers/application_helper.rb

@@ -76,8 +76,9 @@ module ApplicationHelper
   end
 
   def year_distance_stat(year, user)
-    # In km or miles, depending on the user.safe_settings.distance_unit
-    Stat.year_distance(year, user).sum { _1[1] }
+    # Distance is now stored in meters, convert to user's preferred unit for display
+    total_distance_meters = Stat.year_distance(year, user).sum { _1[1] }
+    Stat.convert_distance(total_distance_meters, user.safe_settings.distance_unit)
   end
 
   def past?(year, month)
@@ -98,10 +99,13 @@ module ApplicationHelper
     current_user&.theme == 'light' ? 'light' : 'dark'
   end
 
-  def sidebar_distance(distance)
-    return unless distance
+  def sidebar_distance(distance_meters)
+    return unless distance_meters
 
-    "#{distance} #{current_user.safe_settings.distance_unit}"
+    # Convert from stored meters to user's preferred unit for display
+    user_unit = current_user.safe_settings.distance_unit
+    converted_distance = Stat.convert_distance(distance_meters, user_unit)
+    "#{converted_distance.round(2)} #{user_unit}"
   end
 
   def sidebar_points(points)

app/models/concerns/calculateable.rb

@@ -9,8 +9,8 @@ module Calculateable
   end
 
   def calculate_distance
-    calculated_distance = calculate_distance_from_coordinates
-    self.distance = convert_distance_for_storage(calculated_distance)
+    calculated_distance_meters = calculate_distance_from_coordinates
+    self.distance = convert_distance_for_storage(calculated_distance_meters)
   end
 
   def recalculate_path!
@@ -44,16 +44,14 @@ module Calculateable
     self.original_path = updated_path if respond_to?(:original_path=)
   end
 
-  def user_distance_unit
-    user.safe_settings.distance_unit
-  end
-
   def calculate_distance_from_coordinates
-    Point.total_distance(points, user_distance_unit)
+    # Always calculate in meters for consistent storage
+    Point.total_distance(points, :m)
   end
 
-  def convert_distance_for_storage(calculated_distance)
-    calculated_distance.round(2)
+  def convert_distance_for_storage(calculated_distance_meters)
+    # Store as integer meters for consistency
+    calculated_distance_meters.round
   end
 
   def track_model?

app/models/concerns/distance_convertible.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Module for converting distances from stored meters to user's preferred unit at runtime.
+#
+# All distances are stored in meters in the database for consistency. This module provides
+# methods to convert those stored meter values to the user's preferred unit (km, mi, etc.)
+# for display purposes.
+#
+# This approach ensures:
+# - Consistent data storage regardless of user preferences
+# - No data corruption when users change distance units
+# - Easy conversion for display without affecting stored data
+#
+# Usage:
+#   class Track < ApplicationRecord
+#     include DistanceConvertible
+#   end
+#
+#   track.distance                    # => 5000 (meters stored in DB)
+#   track.distance_in_unit('km')      # => 5.0 (converted to km)
+#   track.distance_in_unit('mi')      # => 3.11 (converted to miles)
+#   track.formatted_distance('km')    # => "5.0 km"
+#
+module DistanceConvertible
+  extend ActiveSupport::Concern
+
+  def distance_in_unit(unit)
+    return 0.0 unless distance.present?
+
+    unit_sym = unit.to_sym
+    conversion_factor = ::DISTANCE_UNITS[unit_sym]
+
+    unless conversion_factor
+      raise ArgumentError, "Invalid unit '#{unit}'. Supported units: #{::DISTANCE_UNITS.keys.join(', ')}"
+    end
+
+    # Distance is stored in meters, convert to target unit
+    distance.to_f / conversion_factor
+  end
+
+  def formatted_distance(unit, precision: 2)
+    converted_distance = distance_in_unit(unit)
+    "#{converted_distance.round(precision)} #{unit}"
+  end
+
+  def distance_for_user(user)
+    user_unit = user.safe_settings.distance_unit
+    distance_in_unit(user_unit)
+  end
+
+  def formatted_distance_for_user(user, precision: 2)
+    user_unit = user.safe_settings.distance_unit
+    formatted_distance(user_unit, precision: precision)
+  end
+
+  module ClassMethods
+    def convert_distance(distance_meters, unit)
+      return 0.0 unless distance_meters.present?
+
+      unit_sym = unit.to_sym
+      conversion_factor = ::DISTANCE_UNITS[unit_sym]
+
+      unless conversion_factor
+        raise ArgumentError, "Invalid unit '#{unit}'. Supported units: #{::DISTANCE_UNITS.keys.join(', ')}"
+      end
+
+      distance_meters.to_f / conversion_factor
+    end
+
+    def format_distance(distance_meters, unit, precision: 2)
+      converted = convert_distance(distance_meters, unit)
+      "#{converted.round(precision)} #{unit}"
+    end
+  end
+end

app/models/point.rb

@@ -117,7 +117,7 @@ class Point < ApplicationRecord
 
   def trigger_incremental_track_generation
     point_date = Time.zone.at(timestamp).to_date
-    return unless point_date >= 1.day.ago.to_date
+    return if point_date < 1.day.ago.to_date
 
     Tracks::IncrementalGeneratorJob.perform_later(user_id, point_date.to_s, 5)
   end

app/models/stat.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 class Stat < ApplicationRecord
+  include DistanceConvertible
+
   validates :year, :month, presence: true
 
   belongs_to :user
@@ -37,8 +39,9 @@ class Stat < ApplicationRecord
   def calculate_daily_distances(monthly_points)
     timespan.to_a.map.with_index(1) do |day, index|
       daily_points = filter_points_for_day(monthly_points, day)
-      distance = Point.total_distance(daily_points, user.safe_settings.distance_unit)
-      [index, distance.round]
+      # Calculate distance in meters for consistent storage
+      distance_meters = Point.total_distance(daily_points, :m)
+      [index, distance_meters.round]
     end
   end
 

app/models/track.rb

@@ -2,6 +2,7 @@
 
 class Track < ApplicationRecord
   include Calculateable
+  include DistanceConvertible
 
   belongs_to :user
   has_many :points, dependent: :nullify

app/models/trip.rb

@@ -2,6 +2,7 @@
 
 class Trip < ApplicationRecord
   include Calculateable
+  include DistanceConvertible
 
   has_rich_text :notes
 

app/models/user.rb

@@ -50,8 +50,9 @@ class User < ApplicationRecord
   end
 
   def total_distance
-    # In km or miles, depending on user.safe_settings.distance_unit
-    stats.sum(:distance)
+    # Distance is stored in meters, convert to user's preferred unit for display
+    total_distance_meters = stats.sum(:distance)
+    Stat.convert_distance(total_distance_meters, safe_settings.distance_unit)
   end
 
   def total_countries

app/serializers/stats_serializer.rb

@@ -9,7 +9,7 @@ class StatsSerializer
 
   def call
     {
-      totalDistanceKm: total_distance,
+      totalDistanceKm: total_distance_km,
       totalPointsTracked: user.tracked_points.count,
       totalReverseGeocodedPoints: reverse_geocoded_points,
       totalCountriesVisited: user.countries_visited.count,
@@ -20,8 +20,10 @@ class StatsSerializer
 
   private
 
-  def total_distance
-    user.stats.sum(:distance)
+  def total_distance_km
+    # Convert from stored meters to kilometers
+    total_distance_meters = user.stats.sum(:distance)
+    (total_distance_meters / 1000.0).round(2)
   end
 
   def reverse_geocoded_points
@@ -32,7 +34,7 @@ class StatsSerializer
     user.stats.group_by(&:year).sort.reverse.map do |year, stats|
       {
         year:,
-        totalDistanceKm: stats.sum(&:distance),
+        totalDistanceKm: stats_distance_km(stats),
         totalCountriesVisited: user.countries_visited.count,
         totalCitiesVisited: user.cities_visited.count,
         monthlyDistanceKm: monthly_distance(year, stats)
@@ -40,15 +42,23 @@ class StatsSerializer
     end
   end
 
+  def stats_distance_km(stats)
+    # Convert from stored meters to kilometers
+    total_meters = stats.sum(&:distance)
+    (total_meters / 1000.0).round(2)
+  end
+
   def monthly_distance(year, stats)
     months = {}
 
-    (1..12).each { |month| months[Date::MONTHNAMES[month]&.downcase] = distance(month, year, stats) }
+    (1..12).each { |month| months[Date::MONTHNAMES[month]&.downcase] = distance_km(month, year, stats) }
 
     months
   end
 
-  def distance(month, year, stats)
-    stats.find { _1.month == month && _1.year == year }&.distance.to_i
+  def distance_km(month, year, stats)
+    # Convert from stored meters to kilometers
+    distance_meters = stats.find { _1.month == month && _1.year == year }&.distance.to_i
+    (distance_meters / 1000.0).round(2)
   end
 end

app/services/tracks/track_builder.rb

@@ -15,14 +15,14 @@
 # 6. Associates all points with the created track
 #
 # Statistics calculated:
-# - Distance: In user's preferred unit (km/miles) with 2 decimal precision
+# - Distance: Always stored in meters as integers for consistency
 # - Duration: Total time in seconds between first and last point
 # - Average speed: In km/h regardless of user's distance unit preference
 # - Elevation gain/loss: Cumulative ascent and descent in meters
 # - Elevation max/min: Highest and lowest altitudes in the track
 #
-# The module respects user preferences for distance units and handles missing
-# elevation data gracefully by providing default values.
+# Distance is converted to user's preferred unit only at display time, not storage time.
+# This ensures consistency when users change their distance unit preferences.
 #
 # Used by:
 # - Tracks::Generator for creating tracks during generation
@@ -85,27 +85,20 @@ module Tracks::TrackBuilder
   end
 
   def calculate_track_distance(points)
-    distance_in_user_unit = Point.total_distance(points, user.safe_settings.distance_unit || 'km')
-    distance_in_user_unit.round(2)
+    # Always calculate and store distance in meters for consistency
+    distance_in_meters = Point.total_distance(points, :m)
+    distance_in_meters.round
   end
 
   def calculate_duration(points)
     points.last.timestamp - points.first.timestamp
   end
 
-  def calculate_average_speed(distance_in_user_unit, duration_seconds)
-    return 0.0 if duration_seconds <= 0 || distance_in_user_unit <= 0
-
-    # Convert distance to meters for speed calculation
-    distance_meters = case user.safe_settings.distance_unit
-                      when 'mi'
-                        distance_in_user_unit * 1609.344 # miles to meters
-                      else
-                        distance_in_user_unit * 1000 # km to meters
-                      end
+  def calculate_average_speed(distance_in_meters, duration_seconds)
+    return 0.0 if duration_seconds <= 0 || distance_in_meters <= 0
 
     # Speed in meters per second, then convert to km/h for storage
-    speed_mps = distance_meters.to_f / duration_seconds
+    speed_mps = distance_in_meters.to_f / duration_seconds
     (speed_mps * 3.6).round(2) # m/s to km/h
   end
 

app/views/stats/_stat.html.erb

@@ -1,31 +1,28 @@
-<div id="<%= dom_id stat %>" class="card w-full bg-base-200 shadow-xl">
-  <div class="card-body">
-    <div class="flex justify-between items-center">
-      <h2 class="card-title">
-        <%= link_to map_url(timespan(stat.month, stat.year)), class: "underline hover:no-underline text-#{header_colors.sample}" do %>
-          <%= Date::MONTHNAMES[stat.month] %>
-        <% end %>
-      </h2>
+<div class="border border-gray-500 rounded-md border-opacity-30 bg-gray-100 dark:bg-gray-800 p-3">
+  <div class="flex justify-between">
+    <h4 class="stat-title text-left"><%= Date::MONTHNAMES[stat.month] %> <%= stat.year %></h4>
 
-      <div class="gap-2">
-        <span class='text-xs text-gray-500'>Last update <%= human_date(stat.updated_at) %></span>
-        <%= link_to '🔄', update_year_month_stats_path(stat.year, stat.month), data: { turbo_method: :put }, class: 'text-sm text-gray-500 hover:underline' %>
+    <div class="flex items-center space-x-2">
+      <%= link_to "Details", points_path(year: stat.year, month: stat.month),
+          class: "link link-primary" %>
     </div>
   </div>
-    <p><%= number_with_delimiter stat.distance %><%= current_user.safe_settings.distance_unit %></p>
-    <% if DawarichSettings.reverse_geocoding_enabled? %>
-      <div class="card-actions justify-end">
+
+  <div class="flex">
+    <div class="stat-value">
+      <p><%= number_with_delimiter stat.distance_in_unit(current_user.safe_settings.distance_unit).round %><%= current_user.safe_settings.distance_unit %></p>
+    </div>
+  </div>
+
+  <div class="stat-desc">
     <%= countries_and_cities_stat_for_month(stat) %>
   </div>
-    <% end %>
-    <% if stat.daily_distance %>
-      <%= column_chart(
-        stat.daily_distance,
-        height: '100px',
-        suffix: " #{current_user.safe_settings.distance_unit}",
-        xtitle: 'Days',
-        ytitle: 'Distance'
-      ) %>
-    <% end %>
-  </div>
+
+  <canvas id="distance-chart-<%= stat.id %>"
+          data-daily-distance="<%= stat.daily_distance %>"
+          data-distance-type="monthly"
+          data-title="<%= Date::MONTHNAMES[stat.month] %> <%= stat.year %>"
+          data-y-axis-title="Distance"
+          suffix: " <%= current_user.safe_settings.distance_unit %>",
+          data-user-settings="<%= current_user.safe_settings.default_settings.to_json %>"></canvas>
 </div>

app/views/stats/index.html.erb

@@ -82,7 +82,9 @@
             </div>
           <% end %>
           <%= column_chart(
-            Stat.year_distance(year, current_user),
+            Stat.year_distance(year, current_user).map { |month_name, distance_meters|
+              [month_name, Stat.convert_distance(distance_meters, current_user.safe_settings.distance_unit).round(2)]
+            },
             height: '200px',
             suffix: " #{current_user.safe_settings.distance_unit}",
             xtitle: 'Days',

app/views/trips/_countries.html.erb

@@ -2,7 +2,7 @@
   <div class="card bg-base-200 shadow-lg">
     <div class="card-body p-4">
       <div class="stat-title text-xs">Distance</div>
-      <div class="stat-value text-lg"><%= trip.distance %> <%= distance_unit %></div>
+      <div class="stat-value text-lg"><%= trip.distance_for_user(current_user).round %> <%= distance_unit %></div>
     </div>
   </div>
   <div class="card bg-base-200 shadow-lg">

app/views/trips/_distance.html.erb

@@ -1,5 +1,5 @@
 <% if trip.distance.present? %>
-  <span class="text-md"><%= trip.distance %> <%= distance_unit %></span>
+  <span class="text-md"><%= trip.distance_for_user(current_user).round %> <%= distance_unit %></span>
 <% else %>
   <span class="text-md">Calculating...</span>
   <span class="loading loading-dots loading-sm"></span>

app/views/trips/_trip.html.erb

@@ -5,7 +5,7 @@
         <span class="hover:underline"><%= trip.name %></span>
       </h2>
       <p class="text-sm text-gray-600 text-center">
-        <%= "#{human_date(trip.started_at)} – #{human_date(trip.ended_at)}, #{trip.distance} #{current_user.safe_settings.distance_unit}" %>
+        <%= "#{human_date(trip.started_at)} – #{human_date(trip.ended_at)}, #{trip.distance_for_user(current_user).round} #{current_user.safe_settings.distance_unit}" %>
       </p>
 
       <div style="width: 100%; aspect-ratio: 1/1;"

spec/models/point_spec.rb

@@ -133,11 +133,13 @@ RSpec.describe Point, type: :model do
     end
 
     describe '#trigger_incremental_track_generation' do
-      let(:point) { create(:point, track: track) }
+      let(:point) do
+        create(:point, track: track, import_id: nil, timestamp: 1.hour.ago.to_i, reverse_geocoded_at: 1.hour.ago)
+      end
       let(:track) { create(:track) }
 
       it 'enqueues Tracks::IncrementalGeneratorJob' do
-        expect { point.trigger_incremental_track_generation }.to have_enqueued_job(Tracks::IncrementalGeneratorJob)
+        expect { point.send(:trigger_incremental_track_generation) }.to have_enqueued_job(Tracks::IncrementalGeneratorJob).with(point.user_id, point.recorded_at.to_date.to_s, 5)
       end
     end
   end

spec/models/stat_spec.rb

@@ -29,7 +29,7 @@ RSpec.describe Stat, type: :model do
           create(:point, user:, lonlat: 'POINT(2 2)', timestamp: DateTime.new(year, 1, 1, 2))
         end
 
-        before { expected_distance[0][1] = 157 }
+        before { expected_distance[0][1] = 156_876 }
 
         it 'returns distance by day' do
           expect(subject).to eq(expected_distance)

spec/models/track_spec.rb

@@ -146,13 +146,12 @@ RSpec.describe Track, type: :model do
         expect(track.distance).to be_a(Numeric)
       end
 
-      it 'stores distance in user preferred unit for Track model' do
-        allow(user).to receive(:safe_settings).and_return(double(distance_unit: 'km'))
-        allow(Point).to receive(:total_distance).and_return(1.5) # 1.5 km
+      it 'stores distance in meters consistently' do
+        allow(Point).to receive(:total_distance).and_return(1500) # 1500 meters
 
         track.calculate_distance
 
-        expect(track.distance).to eq(1.5) # Should be 1.5 km with 2 decimal places precision
+        expect(track.distance).to eq(1500) # Should be stored as meters regardless of user unit preference
       end
     end
 

spec/models/user_spec.rb

@@ -88,11 +88,11 @@ RSpec.describe User, type: :model do
     describe '#total_distance' do
       subject { user.total_distance }
 
-      let!(:stat1) { create(:stat, user:, distance: 10) }
-      let!(:stat2) { create(:stat, user:, distance: 20) }
+      let!(:stat1) { create(:stat, user:, distance: 10_000) }
+      let!(:stat2) { create(:stat, user:, distance: 20_000) }
 
       it 'returns sum of distances' do
-        expect(subject).to eq(30)
+        expect(subject).to eq(30) # 30 km
       end
     end
 

spec/services/stats/calculate_month_spec.rb

@@ -53,15 +53,17 @@ RSpec.describe Stats::CalculateMonth do
                lonlat: 'POINT(9.77973105800526 52.72859111523629)')
       end
 
-      context 'when units are kilometers' do
+      context 'when calculating distance' do
         it 'creates stats' do
           expect { calculate_stats }.to change { Stat.count }.by(1)
         end
 
-        it 'calculates distance' do
+        it 'calculates distance in meters consistently' do
           calculate_stats
 
-          expect(user.stats.last.distance).to eq(340)
+          # Distance should be calculated in meters regardless of user unit preference
+          # The actual distance between the test points is approximately 340 km = 340,000 meters
+          expect(user.stats.last.distance).to be_within(1000).of(340_000)
         end
 
         context 'when there is an error' do
@@ -79,33 +81,16 @@ RSpec.describe Stats::CalculateMonth do
         end
       end
 
-      context 'when units are miles' do
+      context 'when user prefers miles' do
         before do
           user.update(settings: { maps: { distance_unit: 'mi' } })
         end
 
-        it 'creates stats' do
-          expect { calculate_stats }.to change { Stat.count }.by(1)
-        end
-
-        it 'calculates distance' do
+        it 'still stores distance in meters (same as km users)' do
           calculate_stats
 
-          expect(user.stats.last.distance).to eq(211)
-        end
-
-        context 'when there is an error' do
-          before do
-            allow(Stat).to receive(:find_or_initialize_by).and_raise(StandardError)
-          end
-
-          it 'does not create stats' do
-            expect { calculate_stats }.not_to(change { Stat.count })
-          end
-
-          it 'creates a notification' do
-            expect { calculate_stats }.to change { Notification.count }.by(1)
-          end
+          # Distance stored should be the same regardless of user preference (meters)
+          expect(user.stats.last.distance).to be_within(1000).of(340_000)
         end
       end
     end

spec/services/tracks/track_builder_spec.rb

@@ -132,40 +132,20 @@ RSpec.describe Tracks::TrackBuilder do
       ]
     end
 
-    context 'with km unit' do
     before do
-        allow_any_instance_of(Users::SafeSettings).to receive(:distance_unit).and_return('km')
-        allow(Point).to receive(:total_distance).and_return(1.5) # 1.5 km
+      # Mock Point.total_distance to return distance in meters
+      allow(Point).to receive(:total_distance).and_return(1500) # 1500 meters
     end
 
-      it 'stores distance in km' do
+    it 'stores distance in meters regardless of user unit preference' do
       result = builder.calculate_track_distance(points)
-        expect(result).to eq(1.5) # 1.5 km with 2 decimal places precision
-      end
+      expect(result).to eq(1500) # Always stored as meters
     end
 
-    context 'with miles unit' do
-      before do
-        allow_any_instance_of(Users::SafeSettings).to receive(:distance_unit).and_return('miles')
-        allow(Point).to receive(:total_distance).and_return(1.0) # 1 mile
-      end
-
-      it 'stores distance in miles' do
+    it 'rounds distance to nearest meter' do
+      allow(Point).to receive(:total_distance).and_return(1500.7)
       result = builder.calculate_track_distance(points)
-        expect(result).to eq(1) # 1 mile
-      end
-    end
-
-    context 'with nil distance unit (defaults to km)' do
-      before do
-        allow_any_instance_of(Users::SafeSettings).to receive(:distance_unit).and_return(nil)
-        allow(Point).to receive(:total_distance).and_return(2.0)
-      end
-
-      it 'defaults to km and stores distance in km' do
-        result = builder.calculate_track_distance(points)
-        expect(result).to eq(2.0) # 2.0 km with 2 decimal places precision
-      end
+      expect(result).to eq(1501) # Rounded to nearest meter
     end
   end