adding the basis for the full slide system

src/core/presentations.rs

@@ -0,0 +1,121 @@
+use std::path::PathBuf;
+use color_eyre::eyre::Result;
+use serde::{Deserialize, Serialize};
+use sqlx::{prelude::FromRow, query, sqlite::SqliteRow, Row, SqliteConnection};
+use tracing::error;
+
+use crate::model::Model;
+
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum PresKind {
+    Html,
+    #[default]
+    Pdf,
+    Generic,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Presentation {
+    pub id: i32,
+    pub title: String,
+    pub path: PathBuf,
+    pub kind: PresKind,
+}
+
+impl Presentation {
+    pub fn new() -> Self {
+        Self {
+            title: "".to_string(),
+            ..Default::default()
+        }
+    }
+
+    pub fn get_kind(&self) -> &PresKind {
+        &self.kind
+    }
+}
+
+impl FromRow<'_, SqliteRow> for Presentation {
+    fn from_row(row: &SqliteRow) -> sqlx::Result<Self> {
+        Ok(Self {
+            id: row.try_get(0)?,
+            title: row.try_get(1)?,
+            path: PathBuf::from({
+                let string: String = row.try_get(2)?;
+                string
+            }),
+            kind: if row.try_get(3)? {
+                PresKind::Html
+            } else {
+                PresKind::Pdf
+            },
+        })
+    }
+}
+
+impl Model<Presentation> {
+    pub fn load_from_db(&mut self) {
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        rt.block_on(async {
+            let result = query!(r#"SELECT id as "id: i32", title, filePath as "path", html from presentations"#).fetch_all(&mut self.db).await;
+            match result {
+                Ok(v) => {
+                    for presentation in v.into_iter() {
+                        let _ = self.add_item(Presentation {
+                            id: presentation.id,
+                            title: presentation.title,
+                            path: presentation.path.into(),
+                            kind: if presentation.html {
+                                PresKind::Html
+                            } else {
+                                PresKind::Pdf
+                            }
+                        });
+                    }
+                }
+                Err(e) => error!("There was an error in converting presentations: {e}"),
+            }
+        });
+    }
+}
+
+pub async fn get_presentation_from_db(database_id: i32, db: &mut SqliteConnection) -> Result<Presentation> {
+    let row = query(r#"SELECT id as "id: i32", title, filePath as "path", html from presentations where id = $1"#).bind(database_id).fetch_one(db).await?;
+    Ok(Presentation::from_row(&row)?)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use pretty_assertions::assert_eq;
+
+    fn test_presentation() -> Presentation {
+        Presentation {
+            id: 54,
+            title: "20240327T133649--12-isaiah-and-jesus__lesson_project_tfc".into(),
+            path: PathBuf::from(
+                "file:///home/chris/docs/notes/lessons/20240327T133649--12-isaiah-and-jesus__lesson_project_tfc.html",
+            ),
+            kind: PresKind::Html,
+        }
+    }
+
+    #[test]
+    pub fn test_pres() {
+        let pres = Presentation::new();
+        assert_eq!(pres.get_kind(), &PresKind::Pdf)
+    }
+
+    #[test]
+    pub fn test_db_and_model() {
+        let mut presentation_model: Model<Presentation> =
+            Model::default();
+        presentation_model.load_from_db();
+        if let Some(presentation) = presentation_model.find(|p| p.id == 54) {
+            let test_presentation = test_presentation();
+            assert_eq!(&test_presentation, presentation);
+        } else {
+            assert!(false);
+        }
+    }
+}