Remove old code

app/services/tracks/generator.rb

@@ -40,20 +40,17 @@ class Tracks::Generator
   def call
     clean_existing_tracks if should_clean_tracks?
 
-    # Get timestamp range for SQL query
     start_timestamp, end_timestamp = get_timestamp_range
-    
+
     Rails.logger.debug "Generator: querying points for user #{user.id} in #{mode} mode"
-    
-    # Use optimized SQL segmentation with pre-calculated distances
-    untracked_only = (mode == :incremental)
+
     segments = Track.get_segments_with_points(
       user.id,
       start_timestamp,
       end_timestamp,
       time_threshold_minutes,
       distance_threshold_meters,
-      untracked_only: untracked_only
+      untracked_only: mode == :incremental
     )
 
     Rails.logger.debug "Generator: created #{segments.size} segments via SQL"
@@ -110,23 +107,14 @@ class Tracks::Generator
     user.tracked_points.where(timestamp: day_range).order(:timestamp)
   end
 
-  def create_track_from_segment_optimized(segment_data)
+  def create_track_from_segment(segment_data)
     points = segment_data[:points]
     pre_calculated_distance = segment_data[:pre_calculated_distance]
-    
+
     Rails.logger.debug "Generator: processing segment with #{points.size} points"
     return unless points.size >= 2
 
-    track = create_track_from_points_optimized(points, pre_calculated_distance)
-    Rails.logger.debug "Generator: created track #{track&.id}"
-    track
-  end
-
-  def create_track_from_segment(segment)
-    Rails.logger.debug "Generator: processing segment with #{segment.size} points"
-    return unless segment.size >= 2
-
-    track = create_track_from_points(segment)
+    track = create_track_from_points(points, pre_calculated_distance)
     Rails.logger.debug "Generator: created track #{track&.id}"
     track
   end
@@ -194,7 +182,6 @@ class Tracks::Generator
     scope.destroy_all
   end
 
-  # Get timestamp range for SQL query based on mode
   def get_timestamp_range
     case mode
     when :bulk
@@ -204,22 +191,24 @@ class Tracks::Generator
         # Get full range for user
         first_point = user.tracked_points.order(:timestamp).first
         last_point = user.tracked_points.order(:timestamp).last
+
         [first_point&.timestamp || 0, last_point&.timestamp || Time.current.to_i]
       end
     when :daily
       day = start_at&.to_date || Date.current
+
       [day.beginning_of_day.to_i, day.end_of_day.to_i]
     when :incremental
       # For incremental, we need all untracked points up to end_at
       first_point = user.tracked_points.where(track_id: nil).order(:timestamp).first
       end_timestamp = end_at ? end_at.to_i : Time.current.to_i
+
       [first_point&.timestamp || 0, end_timestamp]
     else
       raise ArgumentError, "Unknown mode: #{mode}"
     end
   end
 
-  # Threshold methods from safe_settings
   def distance_threshold_meters
     @distance_threshold_meters ||= user.safe_settings.meters_between_routes.to_i
   end

app/services/tracks/segmentation.rb

@@ -86,14 +86,12 @@ module Tracks::Segmentation
   end
 
   def calculate_km_distance_between_points(point1, point2)
-    # OPTIMIZED: Use PostGIS for more accurate distance calculation (same as track distance)
-    # This maintains consistency with track distance calculations
     distance_meters = Point.connection.select_value(
       'SELECT ST_Distance(ST_GeomFromEWKT($1)::geography, ST_GeomFromEWKT($2)::geography)',
       nil,
       [point1.lonlat, point2.lonlat]
     )
-    
+
     distance_meters.to_f / 1000.0 # Convert meters to kilometers
   end
 

app/services/tracks/track_builder.rb

@@ -49,7 +49,7 @@
 module Tracks::TrackBuilder
   extend ActiveSupport::Concern
 
-  def create_track_from_points(points)
+  def create_track_from_points(points, pre_calculated_distance)
     return nil if points.size < 2
 
     track = Track.new(
@@ -59,54 +59,20 @@ module Tracks::TrackBuilder
       original_path: build_path(points)
     )
 
-    # Calculate track statistics
-    track.distance = calculate_track_distance(points)
-    track.duration = calculate_duration(points)
-    track.avg_speed = calculate_average_speed(track.distance, track.duration)
-
-    # Calculate elevation statistics
-    elevation_stats = calculate_elevation_stats(points)
-    track.elevation_gain = elevation_stats[:gain]
-    track.elevation_loss = elevation_stats[:loss]
-    track.elevation_max = elevation_stats[:max]
-    track.elevation_min = elevation_stats[:min]
-
-    if track.save
-      Point.where(id: points.map(&:id)).update_all(track_id: track.id)
-
-      track
-    else
-      Rails.logger.error "Failed to create track for user #{user.id}: #{track.errors.full_messages.join(', ')}"
-
-      nil
-    end
-  end
-
-  # Optimized version that uses pre-calculated distance from SQL
-  def create_track_from_points_optimized(points, pre_calculated_distance)
-    return nil if points.size < 2
-
-    track = Track.new(
-      user_id: user.id,
-      start_at: Time.zone.at(points.first.timestamp),
-      end_at: Time.zone.at(points.last.timestamp),
-      original_path: build_path(points)
-    )
-
-    # Use pre-calculated distance from SQL instead of recalculating
-    track.distance = pre_calculated_distance.round
-    track.duration = calculate_duration(points)
+    track.distance  = pre_calculated_distance.round
+    track.duration  = calculate_duration(points)
     track.avg_speed = calculate_average_speed(track.distance, track.duration)
 
     # Calculate elevation statistics (no DB queries needed)
     elevation_stats = calculate_elevation_stats(points)
     track.elevation_gain = elevation_stats[:gain]
     track.elevation_loss = elevation_stats[:loss]
-    track.elevation_max = elevation_stats[:max]
-    track.elevation_min = elevation_stats[:min]
+    track.elevation_max  = elevation_stats[:max]
+    track.elevation_min  = elevation_stats[:min]
 
     if track.save
       Point.where(id: points.map(&:id)).update_all(track_id: track.id)
+
       track
     else
       Rails.logger.error "Failed to create track for user #{user.id}: #{track.errors.full_messages.join(', ')}"
@@ -133,6 +99,7 @@ module Tracks::TrackBuilder
 
     # Speed in meters per second, then convert to km/h for storage
     speed_mps = distance_in_meters.to_f / duration_seconds
+
     (speed_mps * 3.6).round(2) # m/s to km/h
   end
 

db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[8.0].define(version: 2025_07_03_193657) do
+ActiveRecord::Schema[8.0].define(version: 2025_07_23_164055) do
   # These are extensions that must be enabled in order to support this database
   enable_extension "pg_catalog.plpgsql"
   enable_extension "postgis"
@@ -146,6 +146,7 @@ ActiveRecord::Schema[8.0].define(version: 2025_07_03_193657) do
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
     t.geography "lonlat", limit: {srid: 4326, type: "st_point", geographic: true}
+    t.index "(((geodata -> 'properties'::text) ->> 'osm_id'::text))", name: "index_places_on_geodata_osm_id"
     t.index ["lonlat"], name: "index_places_on_lonlat", using: :gist
   end
 
@@ -202,6 +203,7 @@ ActiveRecord::Schema[8.0].define(version: 2025_07_03_193657) do
     t.index ["timestamp"], name: "index_points_on_timestamp"
     t.index ["track_id"], name: "index_points_on_track_id"
     t.index ["trigger"], name: "index_points_on_trigger"
+    t.index ["user_id", "timestamp", "track_id"], name: "idx_points_track_generation"
     t.index ["user_id"], name: "index_points_on_user_id"
     t.index ["visit_id"], name: "index_points_on_visit_id"
   end