moving to generic based models instead of traits

src/rust/core/videos.rs

@@ -2,6 +2,9 @@ use crate::model::Model;
 use crate::model::Modeling;
 use color_eyre::eyre::eyre;
 use color_eyre::eyre::Result;
+use sqlx::query;
+use sqlx::query_as;
+use tracing::error;
 use std::mem::replace;
 use std::path::PathBuf;
 
@@ -14,60 +17,61 @@ pub struct Video {
     pub looping: bool,
 }
 
-impl Model<Video> {}
-
-impl Modeling for Model<Video> {
-    type Item = Video;
-
-    fn add_item(&mut self, item: Self::Item) -> Result<()> {
-        self.items.push(item);
-        Ok(())
-    }
-
-    fn add_to_db(&mut self, _item: Self::Item) -> Result<()> {
-        todo!()
-    }
-
-    fn update_item(
-        &mut self,
-        item: Self::Item,
-        index: i32,
-    ) -> Result<()> {
-        if let Some(current_item) = self.items.get_mut(index as usize)
-        {
-            let _old_song = replace(current_item, item);
-            Ok(())
-        } else {
-            Err(eyre!(
-                "Song doesn't exist in model. Id was {}",
-                index
-            ))
-        }
-    }
-
-    fn get_item(&self, index: i32) -> Option<&Self::Item> {
-        self.items.get(index as usize)
-    }
-
-    fn remove_item(&mut self, index: i32) -> Result<()> {
-        self.items.remove(index as usize);
-        Ok(())
-    }
-
-    fn insert_item(
-        &mut self,
-        item: Self::Item,
-        index: i32,
-    ) -> Result<()> {
-        self.items.insert(index as usize, item);
-        Ok(())
+impl Model<Video> {
+    pub fn load_from_db(&mut self) {
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        rt.block_on(async {
+            let result = query_as!(Video, r#"SELECT title as "title!", filePath as "path!", startTime as "start_time!: f32", endTime as "end_time!: f32", loop as "looping!" from videos"#).fetch_all(&mut self.db).await;
+            match result {
+                Ok(v) => {
+                    for video in v.into_iter() {
+                        let _ = self.add_item(video);
+                    }
+                }
+                Err(e) => error!("There was an error in converting songs: {e}"),
+            }
+        });
     }
 }
 
+
 #[cfg(test)]
 mod test {
+    use super::*;
+    use pretty_assertions::{assert_eq, assert_ne};
+
+    fn test_video(title: String) -> Video {
+        Video {
+            title,
+            path: PathBuf::from("~/vids/camprules2024.mp4"),
+            ..Default::default()
+        }
+    }
+
     #[test]
-    pub fn test_video() {
-        assert_eq!(true, true)
+    pub fn test_db_and_model() {
+        let mut video_model: Model<Video> = Model::default();
+        video_model.load_from_db();
+        if let Some(video) = video_model.get_item(3) {
+            let test_video = test_video("Getting started with Tokio. The ultimate starter guide to writing async Rust.".into());
+            assert_eq!(test_video.title, video.title);
+        } else {
+            assert!(false);
+        }
+    }
+
+    #[test]
+    pub fn test_add_video() {
+        let video = test_video("A new video".into());
+        let mut video_model: Model<Video> = Model::default();
+        let result = video_model.add_item(video.clone());
+        let new_video = test_video("A newer video".into());
+        match result {
+            Ok(_) => {
+                assert_eq!(&video, video_model.get_item(0).unwrap());
+                assert_ne!(&new_video, video_model.get_item(0).unwrap());
+            }
+            Err(e) => assert!(false, "There was an error adding the video: {:?}", e),
+        }
     }
 }