Track rank sort

src/components/racers.rs

@@ -79,6 +79,15 @@ fn matches_filters(
                     return false;
                 }
             }
+            RacerField::TrackRank => {
+                let rank_str = racer
+                    .track_rank
+                    .map(|rank| rank.to_string())
+                    .unwrap_or_default();
+                if !rank_str.contains(&filter_lowercase) {
+                    return false;
+                }
+            }
             RacerField::Start => {
                 if !format_time(racer.start)
                     .to_lowercase()
@@ -152,7 +161,7 @@ pub fn Racers(race: Race) -> Element {
                         Th { sorter, field: RacerField::Start, "Start" }
                         Th { sorter, field: RacerField::Finish, "Finish" }
                         Th { sorter, field: RacerField::Time, "Time" }
-                        th { "Track rank" }
+                        Th { sorter, field: RacerField::TrackRank, "Track rank" }
                         th {
                             CategoriesList {
                                 categories: race.categories.clone(),
@@ -174,12 +183,7 @@ pub fn Racers(race: Race) -> Element {
                             td { "{format_time(racer.start)}" }
                             td { "{format_time(racer.finish)}" }
                             td { "{format_time_delta(racer.time)}" }
-                            td {
-                                "{race.tracks_rank.get(&racer.track)
-                                .and_then(|m| m.get(&racer.start_number))
-                                .map(|rank| rank.to_string())
-                                .unwrap_or_default() }"
-                            }
+                            td { "{racer.track_rank.map(|rank| rank.to_string()).unwrap_or_default() }" }
                             td {
                                 for category in racer.categories.clone() {
                                     "{category} "

src/race.rs

@@ -3,7 +3,6 @@ use chrono::{Duration, TimeDelta};
 use serde::{Deserialize, Serialize};
 use std::cell::RefCell;
 use std::cmp::Ordering;
-use std::collections::HashMap;
 use std::collections::HashSet;
 use std::fmt;
 use std::num::ParseIntError;
@@ -55,7 +54,6 @@ pub struct Race {
     pub racers: Vec<Racer>,
     pub categories: Vec<Category>,
     pub tracks: Vec<Track>,
-    pub tracks_rank: HashMap<Track, HashMap<StartNumber, u32>>,
     log: Rc<RefCell<RaceEvents>>,
 }
 
@@ -67,6 +65,7 @@ pub struct Racer {
     pub first_name: String,
     pub last_name: String,
     pub track: Track,
+    pub track_rank: Option<u32>,
     pub categories: Vec<Category>,
     pub start: Option<DateTime<Utc>>,
     pub finish: Option<DateTime<Utc>>,
@@ -80,6 +79,7 @@ pub enum RacerField {
     LastName,
     TagId,
     Track,
+    TrackRank,
     Start,
     Finish,
     Time,
@@ -93,6 +93,12 @@ impl Racer {
             RacerField::LastName => self.last_name.cmp(&other.last_name),
             RacerField::TagId => self.tag.cmp(&other.tag),
             RacerField::Track => self.track.0.cmp(&other.track.0),
+            RacerField::TrackRank => match (self.track_rank, other.track_rank) {
+                (Some(a), Some(b)) => a.cmp(&b),
+                (Some(_), None) => std::cmp::Ordering::Less,
+                (None, Some(_)) => std::cmp::Ordering::Greater,
+                (None, None) => std::cmp::Ordering::Equal,
+            },
             RacerField::Start => self.start.cmp(&other.start),
             RacerField::Finish => self.finish.cmp(&other.finish),
             RacerField::Time => self.time.cmp(&other.time),
@@ -167,6 +173,7 @@ impl Race {
                     first_name: racer.first_name,
                     last_name: racer.last_name,
                     track,
+                    track_rank: None,
                     categories: racer
                         .categories
                         .into_iter()
@@ -184,7 +191,6 @@ impl Race {
             racers,
             categories,
             tracks,
-            tracks_rank: HashMap::new(),
             log: RefCell::new(racelog).into(),
         };
         race.map_start_number_to_track_rank();
@@ -241,9 +247,9 @@ impl Race {
     }
 
     fn calculate_track_rank(&mut self, track: &Track) {
-        let mut finished: Vec<&Racer> = self
+        let mut finished: Vec<&mut Racer> = self
             .racers
-            .iter()
+            .iter_mut()
             .filter(|r| r.track == *track)
             .filter(|r| r.finish.is_some())
             .collect();
@@ -258,12 +264,9 @@ impl Race {
             a.start_number.0.cmp(&b.start_number.0)
         });
 
-        let current_track_rank = self.tracks_rank.entry(track.clone()).or_default();
-
-        current_track_rank.clear(); // Clear previous rankings
-
-        for (rank, r) in finished.into_iter().enumerate() {
-            current_track_rank.insert(r.start_number.clone(), (rank + 1).try_into().unwrap());
+        for (index, r) in finished.into_iter().enumerate() {
+            let rank: u32 = (index + 1) as u32;
+            r.track_rank = Some(rank);
         }
     }
 }