Cargo.lock

@@ -133,17 +133,6 @@ dependencies = [
  "pin-project-lite",
 ]
 
-[[package]]
-name = "async-trait"
-version = "0.1.77"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c980ee35e870bd1a4d2c8294d4c04d0499e67bca1e4b5cefcc693c2fa00caea9"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.48",
-]
-
 [[package]]
 name = "atoi"
 version = "2.0.0"
@@ -431,7 +420,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.41",
 ]
 
 [[package]]
@@ -747,7 +736,7 @@ checksum = "487585f4d0c6655fe74905e2504d8ad6908e4db67f744eb140876906c2f3175d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.41",
 ]
 
 [[package]]
@@ -939,7 +928,6 @@ name = "fitnesstrax"
 version = "0.3.0"
 dependencies = [
  "async-channel",
- "async-trait",
  "chrono",
  "chrono-tz",
  "dimensioned 0.8.0",
@@ -1144,7 +1132,7 @@ checksum = "53b153fd91e4b0147f4aced87be237c98248656bb01050b96bf3ee89220a8ddb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.41",
 ]
 
 [[package]]
@@ -1379,7 +1367,7 @@ dependencies = [
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.41",
 ]
 
 [[package]]
@@ -2455,7 +2443,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.41",
 ]
 
 [[package]]
@@ -2660,7 +2648,7 @@ checksum = "4359fd9c9171ec6e8c62926d6faaf553a8dc3f64e1507e76da7911b4f6a04405"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.41",
 ]
 
 [[package]]
@@ -2804,9 +2792,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.78"
+version = "1.0.70"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae"
+checksum = "39278fbbf5fb4f646ce651690877f89d1c5811a3d4acb27700c1cb3cdb78fd3b"
 dependencies = [
  "unicode-ident",
 ]
@@ -2848,9 +2836,9 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
 
 [[package]]
 name = "quote"
-version = "1.0.35"
+version = "1.0.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
+checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
 dependencies = [
  "proc-macro2",
 ]
@@ -3333,7 +3321,7 @@ checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.41",
 ]
 
 [[package]]
@@ -3732,9 +3720,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.48"
+version = "2.0.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
+checksum = "44c8b28c477cc3bf0e7966561e3460130e1255f7a1cf71931075f1c5e7a7e269"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3830,7 +3818,7 @@ checksum = "01742297787513b79cf8e29d1056ede1313e2420b7b3b15d0a768b4921f549df"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.41",
 ]
 
 [[package]]
@@ -3954,7 +3942,7 @@ checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.41",
 ]
 
 [[package]]
@@ -4075,7 +4063,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.41",
 ]
 
 [[package]]
@@ -4445,7 +4433,7 @@ dependencies = [
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.41",
  "wasm-bindgen-shared",
 ]
 
@@ -4479,7 +4467,7 @@ checksum = "f0eb82fcb7930ae6219a7ecfd55b217f5f0893484b7a13022ebb2b2bf20b5283"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.41",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
@@ -4720,7 +4708,7 @@ checksum = "b3c129550b3e6de3fd0ba67ba5c81818f9805e58b8d7fee80a3a59d2c9fc601a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.41",
 ]
 
 [[package]]

fitnesstrax/app/Cargo.toml

@@ -8,7 +8,6 @@ edition = "2021"
 [dependencies]
 adw             = { version = "0.5", package = "libadwaita", features = [ "v1_4" ] }
 async-channel   = { version = "2.1" }
-async-trait     = { version = "0.1" }
 chrono          = { version = "0.4" }
 chrono-tz       = { version = "0.8" }
 dimensioned     = { version = "0.8", features = [ "serde" ] }

fitnesstrax/app/src/app.rs

@@ -14,7 +14,6 @@ General Public License for more details.
 You should have received a copy of the GNU General Public License along with FitnessTrax. If not, see <https://www.gnu.org/licenses/>.
 */
 
-use async_trait::async_trait;
 use chrono::NaiveDate;
 use emseries::{time_range, Record, RecordId, Series, Timestamp};
 use ft_core::TraxRecord;
@@ -35,32 +34,6 @@ pub enum AppError {
     Unhandled,
 }
 
-#[derive(Debug, Error)]
-pub enum ReadError {
-    #[error("no database loaded")]
-    NoDatabase,
-}
-
-#[derive(Debug, Error)]
-pub enum WriteError {
-    #[error("no database loaded")]
-    NoDatabase,
-    #[error("unhandled error")]
-    Unhandled,
-}
-
-#[async_trait]
-pub trait RecordProvider: Send + Sync {
-    async fn records(
-        &self,
-        start: NaiveDate,
-        end: NaiveDate,
-    ) -> Result<Vec<Record<TraxRecord>>, ReadError>;
-    async fn put_record(&self, record: TraxRecord) -> Result<RecordId, WriteError>;
-    async fn update_record(&self, record: Record<TraxRecord>) -> Result<(), WriteError>;
-    async fn delete_record(&self, id: RecordId) -> Result<(), WriteError>;
-}
-
 /// The real, headless application. This is where all of the logic will reside.
 #[derive(Clone)]
 pub struct App {
@@ -84,26 +57,11 @@ impl App {
         }
     }
 
-    pub async fn open_db(&self, path: PathBuf) -> Result<(), AppError> {
+    pub async fn records(
-        let db_ref = self.database.clone();
-        self.runtime
-            .spawn_blocking(move || {
-                let db = Series::open(path).map_err(|_| AppError::FailedToOpenDatabase)?;
-                *db_ref.write().unwrap() = Some(db);
-                Ok(())
-            })
-            .await
-            .unwrap()
-    }
-}
-
-#[async_trait]
-impl RecordProvider for App {
-    async fn records(
         &self,
         start: NaiveDate,
         end: NaiveDate,
-    ) -> Result<Vec<Record<TraxRecord>>, ReadError> {
+    ) -> Result<Vec<Record<TraxRecord>>, AppError> {
         let db = self.database.clone();
         self.runtime
             .spawn_blocking(move || {
@@ -119,14 +77,14 @@ impl RecordProvider for App {
                         .collect::<Vec<Record<TraxRecord>>>();
                     Ok(records)
                 } else {
-                    Err(ReadError::NoDatabase)
+                    Err(AppError::NoDatabase)
                 }
             })
             .await
             .unwrap()
     }
 
-    async fn put_record(&self, record: TraxRecord) -> Result<RecordId, WriteError> {
+    pub async fn put_record(&self, record: TraxRecord) -> Result<RecordId, AppError> {
         let db = self.database.clone();
         self.runtime
             .spawn_blocking(move || {
@@ -139,10 +97,10 @@ impl RecordProvider for App {
             })
             .await
             .unwrap()
-            .map_err(|_| WriteError::Unhandled)
+            .map_err(|_| AppError::Unhandled)
     }
 
-    async fn update_record(&self, record: Record<TraxRecord>) -> Result<(), WriteError> {
+    pub async fn update_record(&self, record: Record<TraxRecord>) -> Result<(), AppError> {
         let db = self.database.clone();
         self.runtime
             .spawn_blocking(move || {
@@ -154,10 +112,18 @@ impl RecordProvider for App {
             })
             .await
             .unwrap()
-            .map_err(|_| WriteError::Unhandled)
+            .map_err(|_| AppError::Unhandled)
     }
 
-    async fn delete_record(&self, id: RecordId) -> Result<(), WriteError> {
+    pub async fn open_db(&self, path: PathBuf) -> Result<(), AppError> {
-        unimplemented!()
+        let db_ref = self.database.clone();
+        self.runtime
+            .spawn_blocking(move || {
+                let db = Series::open(path).map_err(|_| AppError::FailedToOpenDatabase)?;
+                *db_ref.write().unwrap() = Some(db);
+                Ok(())
+            })
+            .await
+            .unwrap()
     }
 }

fitnesstrax/app/src/app_window.rs

@@ -15,8 +15,7 @@ You should have received a copy of the GNU General Public License along with Fit
 */
 
 use crate::{
-    app::{App, RecordProvider},
+    app::App,
-    types::DayInterval,
     view_models::DayDetailViewModel,
     views::{DayDetailView, HistoricalView, PlaceholderView, View, WelcomeView},
 };
@@ -134,22 +133,23 @@ impl AppWindow {
         self.swap_main(view);
     }
 
-    fn show_historical_view(&self, interval: DayInterval) {
+    fn show_historical_view(&self, records: Vec<Record<TraxRecord>>) {
-        let view = View::Historical(HistoricalView::new(self.app.clone(), interval, {
+        let view = View::Historical(HistoricalView::new(self.app.clone(), records, {
             let s = self.clone();
-            Rc::new(move |date| {
+            Rc::new(move |date, records| {
-                let s = s.clone();
-                glib::spawn_future_local(async move {
                 let layout = gtk::Box::new(gtk::Orientation::Vertical, 0);
                 layout.append(&adw::HeaderBar::new());
-                    let view_model = DayDetailViewModel::new(date, s.app.clone()).await.unwrap();
+                // layout.append(&DayDetailView::new(date, records, s.app.clone()));
-                    layout.append(&DayDetailView::new(view_model));
+                layout.append(&DayDetailView::new(DayDetailViewModel::new(
+                    date,
+                    records,
+                    s.app.clone(),
+                )));
                 let page = &adw::NavigationPage::builder()
                     .title(date.format("%Y-%m-%d").to_string())
                     .child(&layout)
                     .build();
                 s.navigation.push(page);
-                });
             })
         }));
         self.swap_main(view);
@@ -161,7 +161,10 @@ impl AppWindow {
             async move {
                 let end = Local::now().date_naive();
                 let start = end - Duration::days(7);
-                s.show_historical_view(DayInterval { start, end });
+                match s.app.records(start, end).await {
+                    Ok(records) => s.show_historical_view(records),
+                    Err(_) => s.show_welcome_view(),
+                }
             }
         });
     }

fitnesstrax/app/src/components/day.rs

@@ -18,7 +18,6 @@ You should have received a copy of the GNU General Public License along with Fit
 // use ft_core::TraxRecord;
 use crate::{
     components::{steps_editor, weight_field, ActionGroup, Steps, WeightLabel},
-    types::WeightFormatter,
     view_models::DayDetailViewModel,
 };
 use glib::Object;
@@ -163,7 +162,7 @@ impl DayDetail {
         let top_row = gtk::Box::builder()
             .orientation(gtk::Orientation::Horizontal)
             .build();
-        let weight_view = WeightLabel::new(view_model.weight().map(WeightFormatter::from));
+        let weight_view = WeightLabel::new(view_model.weight());
         top_row.append(&weight_view.widget());
 
         let steps_view = Steps::new(view_model.steps());
@@ -223,21 +222,12 @@ impl DayDetail {
 
 pub struct DayEditPrivate {
     on_finished: RefCell<Box<dyn Fn()>>,
-    workout_rows: RefCell<gtk::Box>,
-    view_model: RefCell<Option<DayDetailViewModel>>,
 }
 
 impl Default for DayEditPrivate {
     fn default() -> Self {
         Self {
             on_finished: RefCell::new(Box::new(|| {})),
-            workout_rows: RefCell::new(
-                gtk::Box::builder()
-                    .orientation(gtk::Orientation::Vertical)
-                    .hexpand(true)
-                    .build(),
-            ),
-            view_model: RefCell::new(None),
         }
     }
 }
@@ -267,7 +257,6 @@ impl DayEdit {
         s.set_hexpand(true);
 
         *s.imp().on_finished.borrow_mut() = Box::new(on_finished);
-        *s.imp().view_model.borrow_mut() = Some(view_model.clone());
 
         s.append(
             &ActionGroup::builder()
@@ -294,10 +283,10 @@ impl DayEdit {
             .orientation(gtk::Orientation::Horizontal)
             .build();
         top_row.append(
-            &weight_field(view_model.weight().map(WeightFormatter::from), {
+            &weight_field(view_model.weight(), {
                 let view_model = view_model.clone();
                 move |w| match w {
-                    Some(w) => view_model.set_weight(*w),
+                    Some(w) => view_model.set_weight(w),
                     None => eprintln!("have not implemented record delete"),
                 }
             })

fitnesstrax/app/src/view_models/day_detail.rs

@@ -14,11 +14,9 @@ General Public License for more details.
 You should have received a copy of the GNU General Public License along with FitnessTrax. If not, see <https://www.gnu.org/licenses/>.
 */
 
-use crate::app::{ReadError, RecordProvider, WriteError};
+use crate::{app::App, types::WeightFormatter};
-use chrono::NaiveDate;
-use dimensioned::si;
 use emseries::{Record, RecordId, Recordable};
-use ft_core::{RecordType, TimeDistance, TimeDistanceWorkoutType, TraxRecord};
+use ft_core::TraxRecord;
 use std::{
     collections::HashMap,
     ops::Deref,
@@ -30,6 +28,7 @@ enum RecordState<T: Clone + Recordable> {
     Original(Record<T>),
     New(T),
     Updated(Record<T>),
+    #[allow(unused)]
     Deleted(Record<T>),
 }
 
@@ -44,15 +43,6 @@ impl<T: Clone + emseries::Recordable> RecordState<T> {
         }
     }
 
-    fn exists(&self) -> bool {
-        match self {
-            RecordState::Original(ref r) => true,
-            RecordState::New(ref r) => true,
-            RecordState::Updated(ref r) => true,
-            RecordState::Deleted(ref r) => false,
-        }
-    }
-
     fn with_value(self, value: T) -> RecordState<T> {
         match self {
             RecordState::Original(r) => RecordState::Updated(Record { data: value, ..r }),
@@ -85,20 +75,12 @@ impl<T: Clone + emseries::Recordable> Deref for RecordState<T> {
     }
 }
 
-impl<T: Clone + emseries::Recordable> std::ops::DerefMut for RecordState<T> {
+#[derive(Default)]
-    fn deref_mut(&mut self) -> &mut Self::Target {
+struct DayDetailViewModelInner {}
-        match self {
-            RecordState::Original(ref mut r) => &mut r.data,
-            RecordState::New(ref mut r) => r,
-            RecordState::Updated(ref mut r) => &mut r.data,
-            RecordState::Deleted(ref mut r) => &mut r.data,
-        }
-    }
-}
 
-#[derive(Clone)]
+#[derive(Clone, Default)]
 pub struct DayDetailViewModel {
-    provider: Arc<dyn RecordProvider>,
+    app: Option<App>,
     pub date: chrono::NaiveDate,
     weight: Arc<RwLock<Option<RecordState<ft_core::Weight>>>>,
     steps: Arc<RwLock<Option<RecordState<ft_core::Steps>>>>,
@@ -106,28 +88,13 @@ pub struct DayDetailViewModel {
 }
 
 impl DayDetailViewModel {
-    pub async fn new(
+    pub fn new(date: chrono::NaiveDate, records: Vec<Record<TraxRecord>>, app: App) -> Self {
-        date: chrono::NaiveDate,
-        provider: impl RecordProvider + 'static,
-    ) -> Result<Self, ReadError> {
         let (weight_records, records): (Vec<Record<TraxRecord>>, Vec<Record<TraxRecord>>) =
-            provider
+            records.into_iter().partition(|r| r.data.is_weight());
-                .records(date, date)
-                .await?
-                .into_iter()
-                .partition(|r| r.data.is_weight());
         let (step_records, records): (Vec<Record<TraxRecord>>, Vec<Record<TraxRecord>>) =
             records.into_iter().partition(|r| r.data.is_steps());
-
+        Self {
-        if weight_records.len() > 1 {
+            app: Some(app),
-            eprintln!("warning: multiple weight records found for {}. This is unsupported and the one presented is unpredictable.", date.format("%Y-%m-%d"));
-        }
-        if step_records.len() > 1 {
-            eprintln!("warning: multiple step records found for {}. This is unsupported and the one presented is unpredictable.", date.format("%Y-%m-%d"));
-        }
-
-        Ok(Self {
-            provider: Arc::new(provider),
             date,
             weight: Arc::new(RwLock::new(
                 weight_records
@@ -154,23 +121,25 @@ impl DayDetailViewModel {
                     .map(|r| (r.id.clone(), RecordState::Original(r)))
                     .collect::<HashMap<RecordId, RecordState<TraxRecord>>>(),
             )),
-        })
+        }
     }
 
-    pub fn weight(&self) -> Option<si::Kilogram<f64>> {
+    pub fn weight(&self) -> Option<WeightFormatter> {
-        (*self.weight.read().unwrap()).as_ref().map(|w| (*w).weight)
+        (*self.weight.read().unwrap())
+            .as_ref()
+            .map(|w| WeightFormatter::from(w.weight))
     }
 
-    pub fn set_weight(&self, new_weight: si::Kilogram<f64>) {
+    pub fn set_weight(&self, new_weight: WeightFormatter) {
         let mut record = self.weight.write().unwrap();
         let new_record = match *record {
             Some(ref rstate) => rstate.clone().with_value(ft_core::Weight {
                 date: self.date,
-                weight: new_weight,
+                weight: *new_weight,
             }),
             None => RecordState::New(ft_core::Weight {
                 date: self.date,
-                weight: new_weight,
+                weight: *new_weight,
             }),
         };
         *record = Some(new_record);
@@ -195,135 +164,19 @@ impl DayDetailViewModel {
         *record = Some(new_record);
     }
 
-    pub fn new_time_distance(&self, type_: TimeDistanceWorkoutType) -> Record<TimeDistance> {
-        let id = RecordId::default();
-        let workout = TimeDistance {
-            datetime: chrono::Local::now().into(),
-            distance: None,
-            duration: None,
-            comments: None,
-        };
-        let tr = TraxRecord::from_time_distance(type_, workout.clone());
-        self.records
-            .write()
-            .unwrap()
-            .insert(id.clone(), RecordState::New(tr));
-        println!(
-            "records after new_time_distance: {:?}",
-            self.records.read().unwrap()
-        );
-        Record { id, data: workout }
-    }
-
-    pub fn update_time_distance(&self, workout: Record<TimeDistance>) {
-        let id = workout.id.clone();
-        let data = workout.data.clone();
-
-        let mut record_set = self.records.write().unwrap();
-        if let Some(record_state) = record_set.get(&id).clone() {
-            let updated_state = match **record_state {
-                TraxRecord::BikeRide(_) => {
-                    Some(record_state.clone().with_value(TraxRecord::BikeRide(data)))
-                }
-                TraxRecord::Row(_) => Some(record_state.clone().with_value(TraxRecord::Row(data))),
-                TraxRecord::Run(_) => Some(record_state.clone().with_value(TraxRecord::Run(data))),
-                TraxRecord::Swim(_) => {
-                    Some(record_state.clone().with_value(TraxRecord::Swim(data)))
-                }
-                TraxRecord::Walk(_) => {
-                    Some(record_state.clone().with_value(TraxRecord::Walk(data)))
-                }
-                _ => None,
-            };
-
-            if let Some(updated_state) = updated_state {
-                record_set.insert(id, updated_state);
-            }
-        }
-    }
-
-    pub fn time_distance_records(
-        &self,
-        type_: TimeDistanceWorkoutType,
-    ) -> Vec<Record<TimeDistance>> {
-        self.records
-            .read()
-            .unwrap()
-            .iter()
-            .filter(|(_, record)| record.exists())
-            .filter(|(_, workout_state)| workout_state.is_time_distance_type(type_))
-            .filter_map(|(id, record_state)| match **record_state {
-                TraxRecord::BikeRide(ref workout)
-                | TraxRecord::Row(ref workout)
-                | TraxRecord::Run(ref workout)
-                | TraxRecord::Swim(ref workout)
-                | TraxRecord::Walk(ref workout) => Some(Record {
-                    id: id.clone(),
-                    data: workout.clone(),
-                }),
-                _ => None,
-            })
-            .collect()
-    }
-
-    pub fn time_distance_summary(
-        &self,
-        type_: TimeDistanceWorkoutType,
-    ) -> (si::Meter<f64>, si::Second<f64>) {
-        self.time_distance_records(type_).into_iter().fold(
-            (0. * si::M, 0. * si::S),
-            |(distance, duration), workout| match (workout.data.distance, workout.data.duration) {
-                (Some(distance_), Some(duration_)) => (distance + distance_, duration + duration_),
-                (Some(distance_), None) => (distance + distance_, duration),
-                (None, Some(duration_)) => (distance, duration + duration_),
-                (None, None) => (distance, duration),
-            },
-        )
-    }
-
-    fn get_record(&self, id: &RecordId) -> Option<Record<TraxRecord>> {
-        let record_set = self.records.read().unwrap();
-        match record_set.get(&id) {
-            Some(record) => Some(Record {
-                id: id.clone(),
-                data: (**record).clone(),
-            }),
-            None => None,
-        }
-    }
-
-    pub fn remove_record(&self, id: RecordId) {
-        let mut record_set = self.records.write().unwrap();
-        let updated_record = match record_set.remove(&id) {
-            Some(RecordState::Original(r)) => Some(RecordState::Deleted(r)),
-            Some(RecordState::New(_)) => None,
-            Some(RecordState::Updated(r)) => Some(RecordState::Deleted(r)),
-            Some(RecordState::Deleted(r)) => Some(RecordState::Deleted(r)),
-            None => None,
-        };
-        if let Some(updated_record) = updated_record {
-            record_set.insert(id, updated_record);
-        }
-    }
-
     pub fn save(&self) {
         glib::spawn_future({
             let s = self.clone();
-            async move { s.async_save().await }
+            async move {
-        });
+                if let Some(app) = s.app {
-    }
+                    let weight_record = s.weight.read().unwrap().clone();
-
-    pub async fn async_save(&self) {
-        println!("async_save");
-        let weight_record = self.weight.read().unwrap().clone();
                     match weight_record {
-            Some(RecordState::New(data)) => {
+                        Some(RecordState::New(weight)) => {
-                let _ = self.provider.put_record(TraxRecord::Weight(data)).await;
+                            let _ = app.put_record(TraxRecord::Weight(weight)).await;
                         }
                         Some(RecordState::Original(_)) => {}
                         Some(RecordState::Updated(weight)) => {
-                let _ = self
+                            let _ = app
-                    .provider
                                 .update_record(Record {
                                     id: weight.id,
                                     data: TraxRecord::Weight(weight.data),
@@ -334,15 +187,14 @@ impl DayDetailViewModel {
                         None => {}
                     }
 
-        let steps_record = self.steps.read().unwrap().clone();
+                    let steps_record = s.steps.read().unwrap().clone();
                     match steps_record {
-            Some(RecordState::New(data)) => {
+                        Some(RecordState::New(steps)) => {
-                let _ = self.provider.put_record(TraxRecord::Steps(data)).await;
+                            let _ = app.put_record(TraxRecord::Steps(steps)).await;
                         }
                         Some(RecordState::Original(_)) => {}
                         Some(RecordState::Updated(steps)) => {
-                let _ = self
+                            let _ = app
-                    .provider
                                 .update_record(Record {
                                     id: steps.id,
                                     data: TraxRecord::Steps(steps.data),
@@ -353,7 +205,7 @@ impl DayDetailViewModel {
                         None => {}
                     }
 
-        let records = self
+                    let records = s
                         .records
                         .write()
                         .unwrap()
@@ -362,306 +214,23 @@ impl DayDetailViewModel {
                         .collect::<Vec<RecordState<TraxRecord>>>();
 
                     for record in records {
-            println!("saving record: {:?}", record);
                         match record {
                             RecordState::New(data) => {
-                    let _ = self.provider.put_record(data).await;
+                                let _ = app.put_record(data).await;
                             }
                             RecordState::Original(_) => {}
                             RecordState::Updated(r) => {
-                    let _ = self.provider.update_record(r.clone()).await;
+                                let _ = app.update_record(r.clone()).await;
                             }
-                RecordState::Deleted(r) => {
+                            RecordState::Deleted(_) => unimplemented!(),
-                    let _ = self.provider.delete_record(r.id).await;
                         }
                     }
                 }
             }
+        });
+    }
 
     pub fn revert(&self) {
         unimplemented!();
     }
 }
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use async_trait::async_trait;
-    use chrono::{DateTime, FixedOffset, TimeZone};
-    use dimensioned::si;
-    use emseries::Record;
-
-    #[derive(Clone, Debug)]
-    struct MockProvider {
-        records: Arc<RwLock<HashMap<RecordId, Record<TraxRecord>>>>,
-
-        put_records: Arc<RwLock<Vec<Record<TraxRecord>>>>,
-        updated_records: Arc<RwLock<Vec<Record<TraxRecord>>>>,
-        deleted_records: Arc<RwLock<Vec<RecordId>>>,
-    }
-
-    impl MockProvider {
-        fn new(records: Vec<Record<TraxRecord>>) -> Self {
-            let record_map = records
-                .into_iter()
-                .map(|r| (r.id.clone(), r))
-                .collect::<HashMap<RecordId, Record<TraxRecord>>>();
-            Self {
-                records: Arc::new(RwLock::new(record_map)),
-                put_records: Arc::new(RwLock::new(vec![])),
-                updated_records: Arc::new(RwLock::new(vec![])),
-                deleted_records: Arc::new(RwLock::new(vec![])),
-            }
-        }
-    }
-
-    #[async_trait]
-    impl RecordProvider for MockProvider {
-        async fn records(
-            &self,
-            start: NaiveDate,
-            end: NaiveDate,
-        ) -> Result<Vec<Record<TraxRecord>>, ReadError> {
-            let start = emseries::Timestamp::Date(start);
-            let end = emseries::Timestamp::Date(end);
-            Ok(self
-                .records
-                .read()
-                .unwrap()
-                .iter()
-                .map(|(_, r)| r)
-                .filter(|r| r.timestamp() >= start && r.timestamp() <= end)
-                .cloned()
-                .collect::<Vec<Record<TraxRecord>>>())
-        }
-
-        async fn put_record(&self, record: TraxRecord) -> Result<RecordId, WriteError> {
-            let id = RecordId::default();
-            let record = Record {
-                id: id.clone(),
-                data: record,
-            };
-            self.put_records.write().unwrap().push(record.clone());
-            self.records.write().unwrap().insert(id.clone(), record);
-            Ok(id)
-        }
-
-        async fn update_record(&self, record: Record<TraxRecord>) -> Result<(), WriteError> {
-            println!("updated record: {:?}", record);
-            self.updated_records.write().unwrap().push(record.clone());
-            self.records
-                .write()
-                .unwrap()
-                .insert(record.id.clone(), record);
-            Ok(())
-        }
-
-        async fn delete_record(&self, id: RecordId) -> Result<(), WriteError> {
-            self.deleted_records.write().unwrap().push(id.clone());
-            let _ = self.records.write().unwrap().remove(&id);
-            Ok(())
-        }
-    }
-
-    async fn create_empty_view_model() -> (DayDetailViewModel, MockProvider) {
-        let provider = MockProvider::new(vec![]);
-
-        let oct_13 = chrono::NaiveDate::from_ymd_opt(2023, 10, 13).unwrap();
-        let model = DayDetailViewModel::new(oct_13, provider.clone())
-            .await
-            .unwrap();
-        (model, provider)
-    }
-
-    async fn create_view_model() -> (DayDetailViewModel, MockProvider) {
-        let oct_12 = chrono::NaiveDate::from_ymd_opt(2023, 10, 12).unwrap();
-        let oct_13 = chrono::NaiveDate::from_ymd_opt(2023, 10, 13).unwrap();
-        let oct_13_am: DateTime<FixedOffset> = oct_13
-            .clone()
-            .and_hms_opt(3, 28, 0)
-            .unwrap()
-            .and_utc()
-            .with_timezone(&FixedOffset::east_opt(5 * 3600).unwrap());
-        let provider = MockProvider::new(vec![
-            Record {
-                id: RecordId::default(),
-                data: TraxRecord::Weight(ft_core::Weight {
-                    date: oct_12.clone(),
-                    weight: 93. * si::KG,
-                }),
-            },
-            Record {
-                id: RecordId::default(),
-                data: TraxRecord::Weight(ft_core::Weight {
-                    date: oct_13.clone(),
-                    weight: 95. * si::KG,
-                }),
-            },
-            Record {
-                id: RecordId::default(),
-                data: TraxRecord::Steps(ft_core::Steps {
-                    date: oct_13.clone(),
-                    count: 2500,
-                }),
-            },
-            Record {
-                id: RecordId::default(),
-                data: TraxRecord::BikeRide(ft_core::TimeDistance {
-                    datetime: oct_13_am.clone(),
-                    distance: Some(15000. * si::M),
-                    duration: Some(3600. * si::S),
-                    comments: Some("somecomments present".to_owned()),
-                }),
-            },
-        ]);
-        let model = DayDetailViewModel::new(oct_13, provider.clone())
-            .await
-            .unwrap();
-        (model, provider)
-    }
-
-    #[tokio::test]
-    async fn it_honors_only_the_first_weight_and_step_record() {
-        let (view_model, provider) = create_view_model().await;
-        assert_eq!(view_model.weight(), Some(95. * si::KG));
-        assert_eq!(view_model.steps(), Some(2500));
-    }
-
-    #[tokio::test]
-    async fn it_can_create_a_weight_and_stepcount() {
-        let (view_model, provider) = create_empty_view_model().await;
-        assert_eq!(view_model.weight(), None);
-        assert_eq!(view_model.steps(), None);
-
-        view_model.set_weight(95. * si::KG);
-        view_model.set_steps(250);
-
-        assert_eq!(view_model.weight(), Some(95. * si::KG));
-        assert_eq!(view_model.steps(), Some(250));
-
-        view_model.set_weight(93. * si::KG);
-        view_model.set_steps(255);
-
-        assert_eq!(view_model.weight(), Some(93. * si::KG));
-        assert_eq!(view_model.steps(), Some(255));
-
-        view_model.async_save().await;
-
-        println!("provider: {:?}", provider);
-        assert_eq!(provider.put_records.read().unwrap().len(), 2);
-        assert_eq!(provider.updated_records.read().unwrap().len(), 0);
-        assert_eq!(provider.deleted_records.read().unwrap().len(), 0);
-    }
-
-    #[tokio::test]
-    async fn it_can_construct_new_records() {
-        let (view_model, provider) = create_empty_view_model().await;
-        assert_eq!(
-            view_model.time_distance_summary(TimeDistanceWorkoutType::BikeRide),
-            (0. * si::M, 0. * si::S)
-        );
-
-        let mut record = view_model.new_time_distance(TimeDistanceWorkoutType::BikeRide);
-        record.data.duration = Some(60. * si::S);
-        view_model.async_save().await;
-
-        assert_eq!(provider.put_records.read().unwrap().len(), 1);
-        assert_eq!(provider.updated_records.read().unwrap().len(), 0);
-        assert_eq!(provider.deleted_records.read().unwrap().len(), 0);
-    }
-
-    #[tokio::test]
-    async fn it_can_update_a_new_record_before_saving() {
-        let (view_model, provider) = create_empty_view_model().await;
-        assert_eq!(
-            view_model.time_distance_summary(TimeDistanceWorkoutType::BikeRide),
-            (0. * si::M, 0. * si::S)
-        );
-
-        let mut record = view_model.new_time_distance(TimeDistanceWorkoutType::BikeRide);
-        record.data.duration = Some(60. * si::S);
-        view_model.update_time_distance(record.clone());
-        let record = Record {
-            id: record.id,
-            data: TraxRecord::BikeRide(record.data),
-        };
-        assert_eq!(view_model.get_record(&record.id), Some(record));
-        assert_eq!(
-            view_model.time_distance_summary(TimeDistanceWorkoutType::BikeRide),
-            (0. * si::M, 60. * si::S)
-        );
-        assert_eq!(
-            view_model.time_distance_summary(TimeDistanceWorkoutType::Run),
-            (0. * si::M, 0. * si::S)
-        );
-        view_model.async_save().await;
-
-        assert_eq!(provider.put_records.read().unwrap().len(), 1);
-        assert_eq!(provider.updated_records.read().unwrap().len(), 0);
-        assert_eq!(provider.deleted_records.read().unwrap().len(), 0);
-    }
-
-    #[tokio::test]
-    async fn it_can_update_an_existing_record() {
-        let (view_model, provider) = create_view_model().await;
-        let mut workout = view_model
-            .time_distance_records(TimeDistanceWorkoutType::BikeRide)
-            .first()
-            .cloned()
-            .unwrap();
-
-        println!("found record: {:?}", workout);
-
-        workout.data.duration = Some(1800. * si::S);
-        view_model.update_time_distance(workout.clone());
-
-        assert_eq!(
-            view_model.time_distance_summary(TimeDistanceWorkoutType::BikeRide),
-            (15000. * si::M, 1800. * si::S)
-        );
-
-        view_model.async_save().await;
-
-        assert_eq!(provider.put_records.read().unwrap().len(), 0);
-        assert_eq!(provider.updated_records.read().unwrap().len(), 1);
-        assert_eq!(provider.deleted_records.read().unwrap().len(), 0);
-    }
-
-    #[tokio::test]
-    async fn it_can_remove_a_new_record() {
-        let (view_model, provider) = create_empty_view_model().await;
-        assert_eq!(
-            view_model.time_distance_summary(TimeDistanceWorkoutType::BikeRide),
-            (0. * si::M, 0. * si::S)
-        );
-
-        let record = view_model.new_time_distance(TimeDistanceWorkoutType::BikeRide);
-        view_model.remove_record(record.id);
-        view_model.save();
-
-        assert_eq!(provider.put_records.read().unwrap().len(), 0);
-        assert_eq!(provider.updated_records.read().unwrap().len(), 0);
-        assert_eq!(provider.deleted_records.read().unwrap().len(), 0);
-    }
-
-    #[tokio::test]
-    async fn it_can_delete_an_existing_record() {
-        let (view_model, provider) = create_view_model().await;
-        let mut workout = view_model
-            .time_distance_records(TimeDistanceWorkoutType::BikeRide)
-            .first()
-            .cloned()
-            .unwrap();
-
-        view_model.remove_record(workout.id);
-        assert_eq!(
-            view_model.time_distance_summary(TimeDistanceWorkoutType::BikeRide),
-            (0. * si::M, 0. * si::S)
-        );
-        view_model.async_save().await;
-
-        assert_eq!(provider.put_records.read().unwrap().len(), 0);
-        assert_eq!(provider.updated_records.read().unwrap().len(), 0);
-        assert_eq!(provider.deleted_records.read().unwrap().len(), 1);
-    }
-}

fitnesstrax/app/src/views/day_detail_view.rs

@@ -25,7 +25,7 @@ use std::cell::RefCell;
 #[derive(Default)]
 pub struct DayDetailViewPrivate {
     container: Singleton,
-    view_model: RefCell<Option<DayDetailViewModel>>,
+    view_model: RefCell<DayDetailViewModel>,
 }
 
 #[glib::object_subclass]
@@ -47,7 +47,7 @@ glib::wrapper! {
 impl DayDetailView {
     pub fn new(view_model: DayDetailViewModel) -> Self {
         let s: Self = Object::builder().build();
-        *s.imp().view_model.borrow_mut() = Some(view_model);
+        *s.imp().view_model.borrow_mut() = view_model;
 
         s.append(&s.imp().container);
 
@@ -57,26 +57,18 @@ impl DayDetailView {
     }
 
     fn view(&self) {
-        let view_model = self.imp().view_model.borrow();
+        self.imp()
-        let view_model = view_model
+            .container
-            .as_ref()
+            .swap(&DayDetail::new(self.imp().view_model.borrow().clone(), {
-            .expect("DayDetailView has not been initialized with a view_model")
-            .clone();
-
-        self.imp().container.swap(&DayDetail::new(view_model, {
                 let s = self.clone();
                 move || s.edit()
             }));
     }
 
     fn edit(&self) {
-        let view_model = self.imp().view_model.borrow();
+        self.imp()
-        let view_model = view_model
+            .container
-            .as_ref()
+            .swap(&DayEdit::new(self.imp().view_model.borrow().clone(), {
-            .expect("DayDetailView has not been initialized with a view_model")
-            .clone();
-
-        self.imp().container.swap(&DayEdit::new(view_model, {
                 let s = self.clone();
                 move || s.view()
             }));

fitnesstrax/app/src/views/historical_view.rs

@@ -59,14 +59,11 @@ impl ObjectSubclass for HistoricalViewPrivate {
         factory.connect_bind({
             let app = s.app.clone();
             move |_, list_item| {
-                let app = app.clone();
+                let records = list_item
-                let list_item = list_item.clone();
-                glib::spawn_future_local(async move {
-                    let date = list_item
                     .downcast_ref::<gtk::ListItem>()
                     .expect("should be a ListItem")
                     .item()
-                        .and_downcast::<Date>()
+                    .and_downcast::<DayRecords>()
                     .expect("should be a DaySummary");
 
                 let summary = list_item
@@ -77,13 +74,12 @@ impl ObjectSubclass for HistoricalViewPrivate {
                     .expect("should be a DaySummary");
 
                 if let Some(app) = app.borrow().clone() {
-                        glib::spawn_future_local(async move {
+                    summary.set_data(DayDetailViewModel::new(
-                            let view_model =
+                        records.date(),
-                                DayDetailViewModel::new(date.date(), app).await.unwrap();
+                        records.records(),
-                            summary.set_data(view_model);
+                        app.clone(),
-                        });
+                    ));
                 }
-                });
             }
         });
 
@@ -100,9 +96,13 @@ glib::wrapper! {
 }
 
 impl HistoricalView {
-    pub fn new<SelectFn>(app: App, interval: DayInterval, on_select_day: Rc<SelectFn>) -> Self
+    pub fn new<SelectFn>(
+        app: App,
+        records: Vec<Record<TraxRecord>>,
+        on_select_day: Rc<SelectFn>,
+    ) -> Self
     where
-        SelectFn: Fn(chrono::NaiveDate) + 'static,
+        SelectFn: Fn(chrono::NaiveDate, Vec<Record<TraxRecord>>) + 'static,
     {
         let s: Self = Object::builder().build();
         s.set_orientation(gtk::Orientation::Vertical);
@@ -110,8 +110,11 @@ impl HistoricalView {
 
         *s.imp().app.borrow_mut() = Some(app);
 
-        let mut model = gio::ListStore::new::<Date>();
+        let grouped_records =
-        model.extend(interval.days().map(Date::new));
+            GroupedRecords::new((*s.imp().time_window.borrow()).clone()).with_data(records);
+
+        let mut model = gio::ListStore::new::<DayRecords>();
+        model.extend(grouped_records.items());
         s.imp()
             .list_view
             .set_model(Some(&gtk::NoSelection::new(Some(model))));
@@ -123,8 +126,8 @@ impl HistoricalView {
                 // actually want to do here is to open a modal dialog that shows all of the details of
                 // the day and which allows the user to edit items within that dialog.
                 let item = s.model().unwrap().item(idx).unwrap();
-                let date = item.downcast_ref::<Date>().unwrap();
+                let records = item.downcast_ref::<DayRecords>().unwrap();
-                on_select_day(date.date());
+                on_select_day(records.date(), records.records());
             }
         });
 
@@ -133,9 +136,12 @@ impl HistoricalView {
         s
     }
 
-    pub fn set_interval(&self, interval: DayInterval) {
+    pub fn set_records(&self, records: Vec<Record<TraxRecord>>) {
-        let mut model = gio::ListStore::new::<Date>();
+        println!("set_records: {:?}", records);
-        model.extend(interval.days().map(Date::new));
+        let grouped_records =
+            GroupedRecords::new((self.imp().time_window.borrow()).clone()).with_data(records);
+        let mut model = gio::ListStore::new::<DayRecords>();
+        model.extend(grouped_records.items());
         self.imp()
             .list_view
             .set_model(Some(&gtk::NoSelection::new(Some(model))));
@@ -147,30 +153,152 @@ impl HistoricalView {
 }
 
 #[derive(Default)]
-pub struct DatePrivate {
+pub struct DayRecordsPrivate {
     date: RefCell<chrono::NaiveDate>,
+    records: RefCell<Vec<Record<TraxRecord>>>,
 }
 
 #[glib::object_subclass]
-impl ObjectSubclass for DatePrivate {
+impl ObjectSubclass for DayRecordsPrivate {
-    const NAME: &'static str = "Date";
+    const NAME: &'static str = "DayRecords";
-    type Type = Date;
+    type Type = DayRecords;
 }
 
-impl ObjectImpl for DatePrivate {}
+impl ObjectImpl for DayRecordsPrivate {}
 
 glib::wrapper! {
-    pub struct Date(ObjectSubclass<DatePrivate>);
+    pub struct DayRecords(ObjectSubclass<DayRecordsPrivate>);
 }
 
-impl Date {
+impl DayRecords {
-    pub fn new(date: chrono::NaiveDate) -> Self {
+    pub fn new(date: chrono::NaiveDate, records: Vec<Record<TraxRecord>>) -> Self {
         let s: Self = Object::builder().build();
+
         *s.imp().date.borrow_mut() = date;
+        *s.imp().records.borrow_mut() = records;
+
         s
     }
 
     pub fn date(&self) -> chrono::NaiveDate {
         *self.imp().date.borrow()
     }
+
+    pub fn records(&self) -> Vec<Record<TraxRecord>> {
+        self.imp().records.borrow().clone()
+    }
+
+    pub fn add_record(&self, record: Record<TraxRecord>) {
+        self.imp().records.borrow_mut().push(record);
+    }
+}
+
+// This isn't feeling quite right. DayRecords is a glib object, but I'm not sure that I want to
+// really be passing that around. It seems not generic enough. I feel like this whole grouped
+// records thing can be made more generic.
+struct GroupedRecords {
+    interval: DayInterval,
+    data: HashMap<NaiveDate, DayRecords>,
+}
+
+impl GroupedRecords {
+    fn new(interval: DayInterval) -> Self {
+        let mut s = Self {
+            interval: interval.clone(),
+            data: HashMap::new(),
+        };
+        interval.days().for_each(|date| {
+            let _ = s.data.insert(date, DayRecords::new(date, vec![]));
+        });
+        s
+    }
+
+    fn with_data(mut self, records: Vec<Record<TraxRecord>>) -> Self {
+        records.into_iter().for_each(|record| {
+            self.data
+                .entry(record.date())
+                .and_modify(|entry: &mut DayRecords| (*entry).add_record(record.clone()))
+                .or_insert(DayRecords::new(record.date(), vec![record]));
+        });
+
+        self
+    }
+
+    fn items(&self) -> impl Iterator<Item = DayRecords> + '_ {
+        self.interval.days().map(|date| {
+            self.data
+                .get(&date)
+                .cloned()
+                .unwrap_or(DayRecords::new(date, vec![]))
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::GroupedRecords;
+    use crate::types::DayInterval;
+    use chrono::{FixedOffset, NaiveDate, TimeZone};
+    use dimensioned::si::{KG, M, S};
+    use emseries::{Record, RecordId};
+    use ft_core::{Steps, TimeDistance, TraxRecord, Weight};
+
+    #[test]
+    fn groups_records() {
+        let records = vec![
+            Record {
+                id: RecordId::default(),
+                data: TraxRecord::Steps(Steps {
+                    date: NaiveDate::from_ymd_opt(2023, 10, 13).unwrap(),
+                    count: 1500,
+                }),
+            },
+            Record {
+                id: RecordId::default(),
+                data: TraxRecord::Weight(Weight {
+                    date: NaiveDate::from_ymd_opt(2023, 10, 13).unwrap(),
+                    weight: 85. * KG,
+                }),
+            },
+            Record {
+                id: RecordId::default(),
+                data: TraxRecord::Weight(Weight {
+                    date: NaiveDate::from_ymd_opt(2023, 10, 14).unwrap(),
+                    weight: 86. * KG,
+                }),
+            },
+            Record {
+                id: RecordId::default(),
+                data: TraxRecord::BikeRide(TimeDistance {
+                    datetime: FixedOffset::west_opt(10 * 60 * 60)
+                        .unwrap()
+                        .with_ymd_and_hms(2019, 6, 15, 12, 0, 0)
+                        .unwrap(),
+                    distance: Some(1000. * M),
+                    duration: Some(150. * S),
+                    comments: Some("Test Comments".to_owned()),
+                }),
+            },
+            Record {
+                id: RecordId::default(),
+                data: TraxRecord::BikeRide(TimeDistance {
+                    datetime: FixedOffset::west_opt(10 * 60 * 60)
+                        .unwrap()
+                        .with_ymd_and_hms(2019, 6, 15, 23, 0, 0)
+                        .unwrap(),
+                    distance: Some(1000. * M),
+                    duration: Some(150. * S),
+                    comments: Some("Test Comments".to_owned()),
+                }),
+            },
+        ];
+
+        let groups = GroupedRecords::new(DayInterval {
+            start: NaiveDate::from_ymd_opt(2023, 10, 14).unwrap(),
+            end: NaiveDate::from_ymd_opt(2023, 10, 14).unwrap(),
+        })
+        .with_data(records)
+        .data;
+        assert_eq!(groups.len(), 3);
+    }
 }

fitnesstrax/core/src/lib.rs

@@ -1,4 +1,4 @@
 mod legacy;
 
 mod types;
-pub use types::{RecordType, Steps, TimeDistance, TimeDistanceWorkoutType, TraxRecord, Weight};
+pub use types::{RecordType, Steps, TimeDistance, TraxRecord, Weight};

fitnesstrax/core/src/types.rs

@@ -57,16 +57,6 @@ pub struct TimeDistance {
     pub comments: Option<String>,
 }
 
-impl Recordable for TimeDistance {
-    fn timestamp(&self) -> Timestamp {
-        Timestamp::DateTime(self.datetime)
-    }
-
-    fn tags(&self) -> Vec<String> {
-        vec![]
-    }
-}
-
 /// A singular daily weight measurement. Weight changes slowly enough that it seems unlikely to
 /// need to track more than a single weight in a day.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -96,15 +86,6 @@ pub enum RecordType {
     Weight,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum TimeDistanceWorkoutType {
-    BikeRide,
-    Row,
-    Run,
-    Swim,
-    Walk,
-}
-
 /// The unified data structure for all records that are part of the app.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum TraxRecord {
@@ -118,16 +99,6 @@ pub enum TraxRecord {
 }
 
 impl TraxRecord {
-    pub fn from_time_distance(type_: TimeDistanceWorkoutType, workout: TimeDistance) -> Self {
-        match type_ {
-            TimeDistanceWorkoutType::BikeRide => Self::BikeRide(workout),
-            TimeDistanceWorkoutType::Run => Self::Run(workout),
-            TimeDistanceWorkoutType::Row => Self::Row(workout),
-            TimeDistanceWorkoutType::Swim => Self::Swim(workout),
-            TimeDistanceWorkoutType::Walk => Self::Walk(workout),
-        }
-    }
-
     pub fn workout_type(&self) -> RecordType {
         match self {
             TraxRecord::BikeRide(_) => RecordType::BikeRide,
@@ -147,27 +118,6 @@ impl TraxRecord {
     pub fn is_steps(&self) -> bool {
         matches!(self, TraxRecord::Steps(_))
     }
-
-    pub fn is_time_distance(&self) -> bool {
-        matches!(
-            self,
-            TraxRecord::BikeRide(_)
-                | TraxRecord::Row(_)
-                | TraxRecord::Run(_)
-                | TraxRecord::Swim(_)
-                | TraxRecord::Walk(_)
-        )
-    }
-
-    pub fn is_time_distance_type(&self, type_: TimeDistanceWorkoutType) -> bool {
-        match type_ {
-            TimeDistanceWorkoutType::BikeRide => matches!(self, TraxRecord::BikeRide(_)),
-            TimeDistanceWorkoutType::Row => matches!(self, TraxRecord::Row(_)),
-            TimeDistanceWorkoutType::Run => matches!(self, TraxRecord::Run(_)),
-            TimeDistanceWorkoutType::Swim => matches!(self, TraxRecord::Swim(_)),
-            TimeDistanceWorkoutType::Walk => matches!(self, TraxRecord::Walk(_)),
-        }
-    }
 }
 
 impl Recordable for TraxRecord {