Refactoring to slide_model and service_item getting the data from db

This is kinda a broken commit. There isn't any order to the adding of
the slide anymore. So it'll need to find a way of keeping track of
where all the current slides are and then insert the new ones in the
correct order while moving the others around as well.

src/main.cpp

@@ -142,10 +142,7 @@ int main(int argc, char *argv[])
 
   if (!serviceItemModel.get()->load(settings->getLastSaveFile())) {
     qDebug() << "Last saved file is missing or there isn't a last saved file.";
-    serviceItemModel.get()->addItem(QString::fromUtf8("Black"), QString::fromUtf8("image"),
+    serviceItemModel.get()->addItem(QString::fromUtf8("Black"), QString::fromUtf8("image"), 0);
-                                    QString::fromUtf8("qrc:/assets/black.jpg"),
-                                    QString::fromUtf8("image"), QStringList() << QStringLiteral(""),
-                                    QString::fromUtf8(""), QString::fromUtf8(""), 0, 1, false, 0, 0, 0);
   }
 
   // apparently mpv needs this class set

src/qml/presenter/PreviewSlideListDelegate.qml

@@ -50,12 +50,12 @@ Item {
             chosenFont: model.font
             text: model.text
             pdfIndex: model.slideIndex
-            Connections {
+            /* Connections { */
-                target: slideModel
+            /*     target: slideModel */
-                function onDataChanged() {
+            /*     function onDataChanged() { */
-                    Utils.dbg("hi")
+            /*         Utils.dbg("hi") */
-                }
+            /*     } */
-            }
+            /* } */
 
         }
         /* WebEngineView { */

src/qml/presenter/ServiceList.qml

@@ -559,9 +559,7 @@ Item {
             const image = imageModel.getItem(itemIndex);
             console.log("adding: " + image.title + " of type " + type);
             ServiceItemModel.insertItem(index, image.title,
-                                        "", type, image.filePath,
+                                        type, image.id);
-                                        "image", "",
-                                        "", 0, 0, false, 0.0, 0.0, itemIndex);
             serviceItemList.forceLayout()
             return;
         }
@@ -569,9 +567,7 @@ Item {
             const video = videoModel.getItem(itemIndex);
             console.log("adding: " + video.title + " of type " + type);
             ServiceItemModel.insertItem(index, video.title,
-                                        "", type, video.filePath,
+                                        type, video.id);
-                                        "video", "",
-                                        "", 0, 0, video.loop, video.startTime, video.endTime, itemIndex);
             serviceItemList.forceLayout()
             return;
         }
@@ -583,10 +579,7 @@ Item {
                         " of type " + type +
                         " with " + lyrics.length + " slides");
             ServiceItemModel.insertItem(index, song.title,
-                                        lyrics, type, song.background,
+                                        type, song.id);
-                                        song.backgroundType, 
-                                        song.audio, song.font, song.fontSize,
-                                        lyrics.length, true, 0.0, 0.0, itemIndex);
             serviceItemList.forceLayout()
             return;
         }
@@ -595,10 +588,7 @@ Item {
             console.log("adding: " + pres.title +
                         " of type " + type +
                         " with " + pres.pageCount + " slides");
-            ServiceItemModel.insertItem(index, pres.title,
+            ServiceItemModel.insertItem(index, pres.title, type, pres.id);
-                                        "", type, pres.filePath,
-                                        "image",
-                                        "", "", 0, pres.pageCount, false, 0.0, 0.0, itemIndex);
             serviceItemList.forceLayout()
             return;
         }
@@ -614,9 +604,7 @@ Item {
             const image = imageModel.getItem(itemIndex);
             console.log("adding: " + image.title + " of type " + type);
             ServiceItemModel.addItem(image.title,
-                                     type, image.filePath,
+                                     type, image.id);
-                                     "image", "", "",
-                                     "", 0, 0, false, 0.0, 0.0, itemIndex);
             serviceItemList.forceLayout()
             return;
         }
@@ -624,9 +612,7 @@ Item {
             const video = videoModel.getItem(itemIndex);
             console.log("adding: " + video.title + " of type " + type);
             ServiceItemModel.addItem(video.title,
-                                     type, video.filePath,
+                                     type, video.id);
-                                     "video", "", "",
-                                     "", 0, 0, video.loop, video.startTime, video.endTime, itemIndex);
             serviceItemList.forceLayout()
             return;
         }
@@ -637,10 +623,7 @@ Item {
                         " of type " + type +
                         " with " + lyrics.length + " slides");
             ServiceItemModel.addItem(song.title,
-                                     type, song.background,
+                                     type, song.id);
-                                     song.backgroundType, lyrics,
-                                     song.audio, song.font, song.fontSize,
-                                     lyrics.length, true, 0.0, 0.0, itemIndex);
             serviceItemList.forceLayout()
             return;
         }
@@ -650,10 +633,7 @@ Item {
                         " of type " + type +
                         " with " + pres.pageCount + " slides");
             ServiceItemModel.addItem(pres.title,
-                                     type, pres.filePath,
+                                     type, pres.id);
-                                     "image", "",
-                                     "", "", 0, pres.pageCount,
-                                     false, 0.0, 0.0, itemIndex);
             serviceItemList.forceLayout()
             return;
         }

src/rust/image_model.rs

@@ -172,7 +172,7 @@ use self::image_model::{
 pub struct Image {
     id: i32,
     title: String,
-    path: String,
+    pub path: String,
 }
 
 #[derive(Debug)]
@@ -206,10 +206,22 @@ impl Default for ImageModelRust {
     }
 }
 
-impl ImageModelRust {
+pub fn get_image(index: i32) -> color_eyre::Result<Image> {
-    pub fn get_image(index: i32) -> Option<&Image> {
+    let rt = tokio::runtime::Runtime::new().unwrap();
-        todo!()
+    let mut db = {
-    }
+        let mut data = dirs::data_local_dir().unwrap();
+        data.push("lumina");
+        data.push("library-db.sqlite3");
+        let mut db_url = String::from("sqlite://");
+        db_url.push_str(data.to_str().unwrap());
+        rt.block_on(async {
+            SqliteConnection::connect(&db_url).await.expect("problems")
+        })
+    };
+    rt.block_on(async {
+        let result = query_as!(Image, r#"SELECT id as "id: i32", title as "title!", filePath as "path!" from images where id = ?"#, index).fetch_one(&mut db).await?;
+        Ok(result)
+    })
 }
 
 impl image_model::ImageModel {

src/rust/presentation_model.rs

@@ -197,9 +197,9 @@ use self::presentation_model::{
 pub struct Presentation {
     id: i32,
     title: String,
-    html: bool,
+    pub html: bool,
-    path: String,
+    pub path: String,
-    page_count: i32,
+    pub page_count: i32,
 }
 
 #[derive(Debug)]
@@ -233,10 +233,22 @@ impl Default for PresentationModelRust {
     }
 }
 
-impl PresentationModelRust {
+pub fn get_presentation(index: i32) -> color_eyre::Result<Presentation> {
-    pub fn get_presentation(index: i32) -> Presentation {
+    let rt = tokio::runtime::Runtime::new().unwrap();
-        todo!()
+    let mut db = {
-    }
+        let mut data = dirs::data_local_dir().unwrap();
+        data.push("lumina");
+        data.push("library-db.sqlite3");
+        let mut db_url = String::from("sqlite://");
+        db_url.push_str(data.to_str().unwrap());
+        rt.block_on(async {
+            SqliteConnection::connect(&db_url).await.expect("problems")
+        })
+    };
+    rt.block_on(async {
+        let result = query_as!(Presentation, r#"SELECT id as "id: i32", title as "title!", filePath as "path!", html as "html!", pageCount as "page_count!: i32" from presentations where id = ?"#, index).fetch_one(&mut db).await?;
+        Ok(result)
+    })
 }
 
 impl presentation_model::PresentationModel {

src/rust/service_item_model.rs

@@ -78,7 +78,6 @@ mod service_item_model {
         #[qsignal]
         fn item_added(
             self: Pin<&mut ServiceItemModel>,
-            index: &i32,
             id: &i32,
             kind: &QString,
         );
@@ -122,16 +121,6 @@ mod service_item_model {
             self: Pin<&mut ServiceItemModel>,
             name: QString,
             ty: QString,
-            background: QString,
-            background_type: QString,
-            text: QStringList,
-            audio: QString,
-            font: QString,
-            font_size: i32,
-            slide_count: i32,
-            looping: bool,
-            video_start_time: f32,
-            video_end_time: f32,
             id: i32,
         );
 
@@ -140,17 +129,7 @@ mod service_item_model {
             self: Pin<&mut ServiceItemModel>,
             index: i32,
             name: QString,
-            text: QStringList,
             ty: QString,
-            background: QString,
-            background_type: QString,
-            audio: QString,
-            font: QString,
-            font_size: i32,
-            slide_count: i32,
-            looping: bool,
-            video_start_time: f32,
-            video_end_time: f32,
             id: i32,
         );
 
@@ -423,31 +402,11 @@ impl service_item_model::ServiceItemModel {
         mut self: Pin<&mut Self>,
         name: QString,
         ty: QString,
-        background: QString,
-        background_type: QString,
-        text: QStringList,
-        audio: QString,
-        font: QString,
-        font_size: i32,
-        slide_count: i32,
-        looping: bool,
-        video_start_time: f32,
-        video_end_time: f32,
         id: i32,
     ) {
         let service_item = ServiceItem {
             name,
             ty: ty.try_into().unwrap(),
-            text,
-            background,
-            background_type,
-            audio,
-            font,
-            font_size,
-            slide_count,
-            looping,
-            video_start_time,
-            video_end_time,
             id,
             ..Default::default()
         };
@@ -474,39 +433,19 @@ impl service_item_model::ServiceItemModel {
             self.as_mut().end_insert_rows();
         }
         debug!("ADDING: {:?}", &service_item);
-        self.as_mut().item_added(&index, &service_item.id, &service_item.ty.to_string());
+        self.as_mut().item_added(&service_item.id, &QString::from(&service_item.ty.to_string()));
     }
 
     pub fn insert_item(
         mut self: Pin<&mut Self>,
         index: i32,
         name: QString,
-        text: QStringList,
         ty: QString,
-        background: QString,
-        background_type: QString,
-        audio: QString,
-        font: QString,
-        font_size: i32,
-        slide_count: i32,
-        looping: bool,
-        video_start_time: f32,
-        video_end_time: f32,
         id: i32,
     ) {
         let service_item = ServiceItem {
             name,
             ty: ty.try_into().unwrap(),
-            text,
-            background,
-            background_type,
-            audio,
-            font,
-            font_size,
-            slide_count,
-            looping,
-            video_start_time,
-            video_end_time,
             id,
             ..Default::default()
         };
@@ -533,7 +472,7 @@ impl service_item_model::ServiceItemModel {
             self.as_mut().end_insert_rows();
         }
         debug!("ADDING: {:?}", &service_item);
-        self.as_mut().item_inserted(&index, &service_item.id, &service_item.ty.to_string());
+        self.as_mut().item_inserted(&index, &service_item.id, &QString::from(&service_item.ty.to_string()));
     }
 
     pub fn get_item(

src/rust/slide_model.rs

@@ -101,17 +101,16 @@ pub mod slide_model {
         fn insert_item_from_service(
             self: Pin<&mut SlideModel>,
             index: i32,
-            service_item: &QMap_QString_QVariant,
+            item_model_id: i32,
-            id: i32,
+            kind: &QString,
-        );
+        ) -> Result<()>;
 
         #[qinvokable]
         fn add_item_from_service(
             self: Pin<&mut SlideModel>,
-            index: i32,
+            item_model_id: i32,
-            service_item: &QMap_QString_QVariant,
+            kind: &QString,
-            id: i32,
+        ) -> Result<()>;
-        );
 
         #[qinvokable]
         fn move_item_from_service(
@@ -229,20 +228,25 @@ pub mod slide_model {
 }
 
 use crate::image_model::image_model::ImageModel;
+use crate::image_model::{self, Image, ImageModelRust};
 use crate::presentation_model::presentation_model::PresentationModel;
-use crate::songs::song_model::song_model::SongModel;
+use crate::presentation_model::{self, Presentation, PresentationModelRust};
-use crate::songs::song_model::SongModelRust;
+use crate::songs::song_model::song_model::{self, SongModel};
+use crate::songs::song_model::{get_song, Song, SongModelRust};
 use crate::video_model::video_model::VideoModel;
-use crate::video_model::VideoModelRust;
+use crate::video_model::{self, Video, VideoModelRust};
 use crate::{ffmpeg, slide_types::SlideType};
 use crate::obs::Obs;
 use crate::slide_model::slide_model::QList_QString;
-use color_eyre::owo_colors::OwoColorize;
+use color_eyre::eyre::Result;
+use color_eyre::Section;
 use cxx_qt::{CxxQtType, Threading};
 use cxx_qt_lib::{
-    CaseSensitivity, QByteArray, QModelIndex, QString, QStringList, QVariant
+    CaseSensitivity, QByteArray, QList, QModelIndex, QString, QStringList, QVariant
 };
 use slide_model::SlideObject;
+use std::error::Error;
+use std::fmt::{Display};
 use std::{path::PathBuf, pin::Pin};
 use tracing::{debug, error};
 
@@ -302,6 +306,111 @@ impl Default for Slide {
     }
 }
 
+#[derive(Debug)]
+pub enum ParseSlideError {
+    UnknownType,
+}
+
+impl Error for ParseSlideError {}
+
+impl Display for ParseSlideError {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        let message = match self {
+            Self::UnknownType => "The type does not exist. It needs to be one of 'song', 'video', 'image', 'presentation', or 'content'",
+        };
+        write!(f, "Error: {message}")
+    }
+}
+
+impl TryFrom<Video> for Slide {
+    type Error = ParseSlideError;
+    fn try_from(value: Video) -> Result<Self, Self::Error> {
+        todo!()
+    }
+}
+
+impl Slide {
+    fn slides_from_song(song: Song) -> Result<Vec<Self>> {
+        let list = song.get_lyric_list();
+        let total = list.len();
+        let mut vector: Vec<Slide> = vec![];
+        list.iter().map(|t| t.to_string()).enumerate()
+            .for_each(|(i, s)| {
+            if song.background_type == "image" {
+                vector.push(
+                    Self {
+                        text: s,
+                        ty: SlideType::Song,
+                        audio: song.audio.clone(),
+                        image_background: song.background.clone(),
+                        video_background: "".to_owned(),
+                        htext_alignment: song.horizontal_text_alignment.clone(),
+                        vtext_alignment: song.vertical_text_alignment.clone(),
+                        font: song.font.clone(),
+                        font_size: song.font_size,
+                        slide_count: total as i32,
+                        slide_index: i as i32,
+                        ..Default::default()
+                    }
+                );
+            } else {
+                vector.push(
+                    Self {
+                        text: s,
+                        ty: SlideType::Song,
+                        audio: song.audio.clone(),
+                        image_background: "".to_owned(),
+                        video_background: song.background.clone(),
+                        htext_alignment: song.horizontal_text_alignment.clone(),
+                        vtext_alignment: song.vertical_text_alignment.clone(),
+                        font: song.font.clone(),
+                        font_size: song.font_size,
+                        slide_count: total as i32,
+                        slide_index: i as i32,
+                        ..Default::default()
+                    }
+                )
+            }
+        });
+        Ok(vector)
+    }
+
+    fn slide_from_video(video: Video) -> Result<Self> {
+        Ok(Self {
+            video_background: video.path,
+            video_start_time: video.start_time,
+            video_end_time: video.end_time,
+            looping: video.looping,
+            ..Default::default()
+        })
+    }
+
+    fn slide_from_image(image: Image) -> Result<Self> {
+        Ok(Self {
+            image_background: image.path,
+            ..Default::default()
+        })
+    }
+
+    fn slides_from_presentation(presentation: Presentation) -> Result<Vec<Self>> {
+        let total = presentation.page_count;
+        let mut slides: Vec<Slide> = vec![];
+        for i in 0..total {
+            slides.push(Self {
+                html: presentation.html,
+                slide_count: total,
+                slide_index: i,
+                image_background: presentation.path.clone(),
+                ..Default::default()
+            })
+        };
+        Ok(slides)
+    }
+}
+
 #[derive(Debug)]
 pub struct SlideModelRust {
     current_index: i32,
@@ -499,379 +608,57 @@ impl slide_model::SlideModel {
     pub fn insert_item_from_service(
         mut self: Pin<&mut Self>,
         index: i32,
-        service_item: &QMap_QString_QVariant,
+        item_model_id: i32,
-        id: i32,
+        kind: &QString,
-    ) {
+    ) -> Result<()> {
-        debug!(index, "Inserting slide from service insert");
+        let kind = SlideType::try_from(kind.clone())?;
-        for (key, data) in service_item.iter() {
+        match kind {
-            debug!(
+            SlideType::Song => {
-                ?key,
+                let song = get_song(item_model_id)?;
-                data = data.value_or_default::<QString>().to_string()
+                let slides = Slide::slides_from_song(song)?;
-            );
+                slides.iter().for_each(|slide| self.as_mut().insert_slide(slide, index));
+                Ok(())
+            },
+            SlideType::Video => {
+                let video = video_model::get_video(item_model_id)?;
+                self.insert_slide(&Slide::slide_from_video(video)?, index);
+                Ok(())
+            },
+            SlideType::Image => {
+                let result = image_model::get_image(item_model_id);
+                match result {
+                    Ok(image) => self.insert_slide(&Slide::slide_from_image(image)?, index),
+                    Err(e) => {
+                        e.with_note(|| {
+                            format!("This might fail if we are loading the items from a file")
+                        });
+                        let mut slide = Slide::default();
+                        slide.image_background = "qrc:/assets/black.jpg".to_owned();
+                        self.insert_slide(&slide, index);
+                    },
                 }
-        let ty = service_item
+                Ok(())
-            .get(&QString::from("ty"))
+            },
-            .unwrap_or(QVariant::from(&QString::from("")))
+            SlideType::Content => {
-            .value::<QString>();
+                todo!();
-
+                Ok(())
-        let background = service_item
+            },
-            .get(&QString::from("background"))
+            SlideType::Presentation(_) => {
-            .unwrap_or(QVariant::from(&QString::from("")))
+                let presentation = presentation_model::get_presentation(item_model_id)?;
-            .value::<QString>()
+                let slides = Slide::slides_from_presentation(presentation)?;
-            .unwrap_or_default();
+                slides.iter().for_each(|slide| self.as_mut().insert_slide(slide, slide.slide_index + index));
-
+                Ok(())
-        let background_type = service_item
-            .get(&QString::from("backgroundType"))
-            .unwrap_or(QVariant::from(&QString::from("")))
-            .value::<QString>()
-            .unwrap_or_default();
-
-        let textlist = service_item
-            .get(&QString::from("text"))
-            .unwrap_or(QVariant::from(&QString::from("")))
-            .value::<QStringList>()
-            .unwrap_or_default();
-
-        let text_vec =
-            Vec::<QString>::from(&QList_QString::from(&textlist));
-        // let vec_slize: &[usize] = &text_vec;
-
-        let mut slide = Slide {
-            ty: SlideType::try_from(extract_string(service_item, "type")).unwrap(),
-            text: extract_string(service_item, "text"),
-            image_background: extract_string(service_item, "imageBackground"),
-            video_background: extract_string(service_item, "videoBackground"),
-            audio: extract_string(service_item, "audio"),
-            font: extract_string(service_item, "font"),
-            htext_alignment: extract_string(service_item, "htextAlignment"),
-            vtext_alignment: extract_string(service_item, "vtextAlignment"),
-            service_item_id: index,
-            font_size: extract_value(service_item, "fontSize"),
-            slide_index: extract_value(service_item, "slideNumber"),
-            slide_count: extract_value(service_item, "slideCount"),
-            video_start_time: extract_float(service_item, "videoStartTime"),
-            video_end_time: extract_float(service_item, "videoEndTime"),
-            video_thumbnail: "".to_owned(),
-            looping: extract_bool(service_item, "loop"),
-            active: extract_bool(service_item, "active"),
-            selected: extract_bool(service_item, "selected"),
-            ..Default::default()
-        };
-
-        slide.font_size = service_item
-            .get(&QString::from("fontSize"))
-            .unwrap_or(QVariant::from(&50))
-            .value()
-            .unwrap_or(50);
-        slide.slide_index = service_item
-            .get(&QString::from("slideNumber"))
-            .unwrap_or(QVariant::from(&0))
-            .value()
-            .unwrap_or(0);
-        slide.slide_count = service_item
-            .get(&QString::from("slideCount"))
-            .unwrap_or(QVariant::from(&1))
-            .value()
-            .unwrap_or(1);
-        slide.video_thumbnail = String::from("");
-
-        let mut binding = self.as_mut().rust_mut();
-        let slides_iter = binding.slides.iter_mut();
-        let mut slide_index = 0;
-        for (i, slide) in slides_iter.enumerate() {
-            if slide.service_item_id == index {
-                slide_index = i as i32;
-                break;
             }
         }
-
-        // We need to move all the current slides service_item_id's up by one.
-        let slides_iter = binding.slides.iter_mut();
-        for slide in
-            slides_iter.filter(|x| x.service_item_id >= index)
-        {
-            slide.service_item_id += 1;
-        }
-
-        match ty {
-            Some(ty) if ty == QString::from("image") => {
-                slide.ty = ty.try_into().unwrap();
-                slide.image_background = background.to_string();
-                slide.video_background = String::from("");
-                slide.slide_index = 0;
-                self.as_mut().insert_slide(&slide, slide_index);
-                debug!("Image added to slide model!");
-            }
-            Some(ty) if ty == QString::from("song") => {
-                let count = text_vec.len();
-                for (i, text) in text_vec.iter().enumerate() {
-                    debug!(
-                        "rust: add song of {:?} length at index {:?}",
-                        &count, &slide_index
-                    );
-                    slide.ty = ty.clone().try_into().unwrap();
-                    // debug!("{:?}", text_vec[i].clone());
-                    slide.text = text.clone().to_string();
-                    slide.slide_count = count as i32;
-                    slide.slide_index = i as i32;
-                    if background_type == QString::from("image") {
-                        slide.image_background = background.clone().to_string();
-                        slide.video_background = String::from("");
-                    } else {
-                        slide.video_background = background.clone().to_string();
-                        slide.image_background = String::from("");
-                    }
-                    self.as_mut()
-                        .insert_slide(&slide, slide_index + i as i32);
-                }
-            }
-            Some(ty) if ty == QString::from("video") => {
-                slide.ty = ty.try_into().unwrap();
-                slide.image_background = String::from("");
-                slide.video_background = background.to_string();
-                slide.slide_index = 0;
-                self.as_mut().insert_slide(&slide, slide_index);
-            }
-            Some(ty) if ty == QString::from("presentation") => {
-                debug!(?slide, "Inserting presentation slide");
-                if background.clone().ends_with(
-                    &QString::from(".html"),
-                    CaseSensitivity::CaseInsensitive,
-                ) {
-                    slide.ty = ty.clone().try_into().unwrap();
-                    slide.html = true;
-                    slide.image_background = background.clone().to_string();
-                    slide.video_background = String::from("");
-                    slide.slide_index = 0;
-                    self.as_mut().insert_slide(&slide, slide_index);
-                } else {
-                    for i in 0..slide.slide_count {
-                        slide.ty = ty.clone().try_into().unwrap();
-                        slide.image_background = background.clone().to_string();
-                        slide.video_background = String::from("");
-                        slide.slide_index = i;
-                        self.as_mut()
-                            .insert_slide(&slide, slide_index + i);
-                    }
-                }
-            }
-            _ => debug!("It's somethign else!"),
-        };
-
-        debug!("Item added in slide model!");
     }
 
     pub fn add_item_from_service(
-        mut self: Pin<&mut Self>,
+        self: Pin<&mut Self>,
-        index: i32,
+        item_model_id: i32,
-        id: i32,
         kind: &QString,
-    ) {
+    ) -> Result<()>{
-        debug!("add rust slide {:?}", index);
+        let index = self.count;
-        let mut slide = Slide::default();
+        self.insert_item_from_service(index, item_model_id, kind)
-        let iter = service_item.iter();
-        if let Ok(kind) = SlideType::try_from(kind) {
-            match kind {
-                SlideType::Song => {
-                    let song = SongModelRust::get_song(id)?;
-                },
-                SlideType::Video => {
-                    let video = VideoModelRust::get_video(id)?;
-                },
-                SlideType::Image => {
-                    let image = ImageModelRust::get_image(id)?;
-                },
-                SlideType::Content => {
-                    todo!()
-                },
-                SlideType::Presentation(_) => {
-                    let presentation = PresentationModelRust::get_presentation(id)?;
-                }
-            }
-        }
-
-        for (key, _value) in iter {
-            debug!(?key);
-            // match key.to_string().as_str() {
-            //     "ty" => slide.ty = QString::from(value),
-            //     // "background" => {
-            //     //     slide.background = QString::from(value)
-            //     // }
-            //     // "backgroundType" => {
-            //     //     slide.background_type = QString::from(value)
-            //     // }
-            //     "audio" => slide.audio = QString::from(value),
-            //     "font" => slide.font = QString::from(value),
-            //     "fontSize" => slide.font_size = i32::from(value),
-            //     "looping" => slide.looping = bool::from(value),
-            //     "slideCount" => slide.slide_count = i32::from(value),
-            //     "videoEndTime" => {
-            //         slide.video_end_time = f32::from(value)
-            //     }
-            //     "videoStartTime" => {
-            //         slide.video_end_time = f32::from(value)
-            //     }
-            // }
-        }
-
-        let ty = service_item
-            .get(&QString::from("ty"))
-            .unwrap_or(QVariant::from(&QString::from("")))
-            .value::<QString>();
-
-        let background = service_item
-            .get(&QString::from("background"))
-            .unwrap_or(QVariant::from(&QString::from("")))
-            .value::<QString>()
-            .unwrap_or_default();
-
-        let background_type = service_item
-            .get(&QString::from("backgroundType"))
-            .unwrap_or(QVariant::from(&QString::from("")))
-            .value::<QString>()
-            .unwrap_or_default();
-
-        let textlist = service_item
-            .get(&QString::from("text"))
-            .unwrap_or(QVariant::from(&QString::from("")))
-            .value::<QStringList>()
-            .unwrap_or_default();
-
-        let text_vec =
-            Vec::<QString>::from(&QList_QString::from(&textlist));
-        // let vec_slize: &[usize] = &text_vec;
-
-        slide.ty = service_item
-            .get(&QString::from("type"))
-            .unwrap_or(QVariant::from(&QString::from("")))
-            .value()
-            .unwrap_or(QString::from("")).try_into().unwrap_or(SlideType::Image);
-        slide.text = service_item
-            .get(&QString::from("text"))
-            .unwrap_or(QVariant::from(&QString::from("")))
-            .value()
-            .unwrap_or(QString::from("")).to_string();
-        slide.image_background = service_item
-            .get(&QString::from("imageBackground"))
-            .unwrap_or(QVariant::from(&QString::from("")))
-            .value()
-            .unwrap_or(QString::from("")).to_string();
-        slide.video_background = service_item
-            .get(&QString::from("videoBackground"))
-            .unwrap_or(QVariant::from(&QString::from("")))
-            .value()
-            .unwrap_or(QString::from("")).to_string();
-        slide.audio = service_item
-            .get(&QString::from("audio"))
-            .unwrap_or(QVariant::from(&QString::from("")))
-            .value()
-            .unwrap_or(QString::from("")).to_string();
-        slide.font = service_item
-            .get(&QString::from("font"))
-            .unwrap_or(QVariant::from(&QString::from("")))
-            .value()
-            .unwrap_or(QString::from("")).to_string();
-        slide.font_size = service_item
-            .get(&QString::from("fontSize"))
-            .unwrap_or(QVariant::from(&50))
-            .value()
-            .unwrap_or(50);
-        slide.htext_alignment = service_item
-            .get(&QString::from("vtextAlignment"))
-            .unwrap_or(QVariant::from(&QString::from("center")))
-            .value()
-            .unwrap_or(QString::from("center")).to_string();
-        slide.vtext_alignment = service_item
-            .get(&QString::from("vtextAlignment"))
-            .unwrap_or(QVariant::from(&QString::from("center")))
-            .value()
-            .unwrap_or(QString::from("center")).to_string();
-        slide.service_item_id = index;
-        slide.slide_index = service_item
-            .get(&QString::from("slideNumber"))
-            .unwrap_or(QVariant::from(&0))
-            .value()
-            .unwrap_or(0);
-        slide.slide_count = service_item
-            .get(&QString::from("slideCount"))
-            .unwrap_or(QVariant::from(&1))
-            .value()
-            .unwrap_or(1);
-        slide.looping = service_item
-            .get(&QString::from("loop"))
-            .unwrap_or(QVariant::from(&false))
-            .value()
-            .unwrap_or(false);
-        slide.active = service_item
-            .get(&QString::from("active"))
-            .unwrap_or(QVariant::from(&false))
-            .value()
-            .unwrap_or(false);
-        slide.selected = service_item
-            .get(&QString::from("selected"))
-            .unwrap_or(QVariant::from(&false))
-            .value()
-            .unwrap_or(false);
-        slide.video_thumbnail = String::from("");
-
-        match ty {
-            Some(ty) if ty == QString::from("image") => {
-                slide.ty = ty.try_into().unwrap_or(SlideType::Image);
-                slide.image_background = background.to_string();
-                slide.video_background = String::from("");
-                slide.slide_index = 0;
-                self.as_mut().add_slide(&slide);
-            }
-            Some(ty) if ty == QString::from("song") => {
-                for (i, text) in text_vec.iter().enumerate() {
-                    slide.ty = ty.clone().try_into().unwrap_or(SlideType::Image);
-                    // debug!("{:?}", text_vec[i].clone());
-                    slide.text = text.clone().to_string();
-                    slide.slide_count = text_vec.len() as i32;
-                    slide.slide_index = i as i32;
-                    if background_type == QString::from("image") {
-                        slide.image_background = background.clone().to_string();
-                        slide.video_background = String::from("");
-                    } else {
-                        slide.video_background = background.clone().to_string();
-                        slide.image_background = String::from("");
-                    }
-                    self.as_mut().add_slide(&slide);
-                }
-            }
-            Some(ty) if ty == QString::from("video") => {
-                slide.ty = ty.try_into().unwrap_or(SlideType::Image);
-                slide.image_background = String::from("");
-                slide.video_background = background.to_string();
-                slide.slide_index = 0;
-                self.as_mut().add_slide(&slide);
-            }
-            Some(ty) if ty == QString::from("presentation") => {
-                debug!(?slide, "Inserting presentation slide");
-                if background.clone().ends_with(
-                    &QString::from(".html"),
-                    CaseSensitivity::CaseInsensitive,
-                ) {
-                    slide.ty = ty.clone().try_into().unwrap_or(SlideType::Image);
-                    slide.html = true;
-                    slide.image_background = background.clone().to_string();
-                    slide.video_background = String::from("");
-                    slide.slide_index = 0;
-                    self.as_mut().add_slide(&slide);
-                } else {
-                    for i in 0..slide.slide_count {
-                        slide.ty = ty.clone().try_into().unwrap_or(SlideType::Image);
-                        slide.image_background = background.clone().to_string();
-                        slide.video_background = String::from("");
-                        slide.slide_index = i;
-                        self.as_mut().add_slide(&slide);
-                    }
-                }
-            }
-            _ => debug!("It's somethign else!"),
-        };
-
-        debug!("Item added in rust model!");
     }
 
     pub fn move_item_from_service(

src/rust/songs/song_model.rs

@@ -285,6 +285,97 @@ impl Default for Song {
     }
 }
 
+impl Song {
+    pub fn get_lyric_list(&self) -> QList_QString {
+        let mut lyric_list = QList_QString::default();
+            if self.lyrics.is_empty() {
+                return QList_QString::default();
+            }
+            let raw_lyrics = self.lyrics.clone();
+            println!("raw-lyrics: {:?}", raw_lyrics);
+            let vorder: Vec<&str> =
+                self.verse_order.split(' ').collect();
+            let keywords = vec![
+                "Verse 1", "Verse 2", "Verse 3", "Verse 4",
+                "Verse 5", "Verse 6", "Verse 7", "Verse 8",
+                "Chorus 1", "Chorus 2", "Chorus 3", "Chorus 4",
+                "Bridge 1", "Bridge 2", "Bridge 3", "Bridge 4",
+                "Intro 1", "Intro 2", "Ending 1", "Ending 2",
+                "Other 1", "Other 2", "Other 3", "Other 4",
+            ];
+            let _first_item = true;
+
+            let mut lyric_map = HashMap::new();
+            let mut verse_title = String::from("");
+            let mut lyric = String::from("");
+            for (i, line) in raw_lyrics.split('\n').enumerate() {
+                if keywords.contains(&line) {
+                    if i != 0 {
+                        // println!("{verse_title}");
+                        // println!("{lyric}");
+                        lyric_map.insert(verse_title, lyric);
+                        lyric = String::from("");
+                        verse_title = line.to_string();
+                        // println!("{line}");
+                        // println!("\n");
+                    } else {
+                        verse_title = line.to_string();
+                        // println!("{line}");
+                        // println!("\n");
+                    }
+                } else {
+                    lyric.push_str(line);
+                    lyric.push('\n');
+                }
+            }
+            lyric_map.insert(verse_title, lyric);
+            // println!("da-map: {:?}", lyric_map);
+
+            for verse in vorder {
+                let mut verse_name = "";
+                // debug!(verse = verse);
+                for word in keywords.clone() {
+                    let end_verse =
+                        verse.get(1..2).unwrap_or_default();
+                    let beg_verse =
+                        verse.get(0..1).unwrap_or_default();
+                    // println!(
+                    //     "verse: {:?}, beginning: {:?}, end: {:?}, word: {:?}",
+                    //     verse, beg_verse, end_verse, word
+                    // );
+                    if word.starts_with(beg_verse)
+                        && word.ends_with(end_verse)
+                    {
+                        verse_name = word;
+                        // println!("TITLE: {verse_name}");
+                        continue;
+                    }
+                }
+                if let Some(lyric) = lyric_map.get(verse_name) {
+                    if lyric.contains("\n\n") {
+                        let split_lyrics: Vec<&str> =
+                            lyric.split("\n\n").collect();
+                        for lyric in split_lyrics {
+                            if lyric.is_empty() {
+                                continue;
+                            }
+                            lyric_list.append(QString::from(lyric));
+                        }
+                        continue;
+                    }
+                    lyric_list.append(QString::from(lyric));
+                } else {
+                    println!("NOT WORKING!");
+                };
+            }
+            for lyric in lyric_list.iter() {
+                // println!("da-list: {:?}", lyric);
+                debug!(lyric = ?lyric)
+            }
+        lyric_list
+    }
+}
+
 #[derive(Debug)]
 pub struct SongModelRust {
     count: i32,
@@ -316,10 +407,7 @@ impl Default for SongModelRust {
     }
 }
 
-const SELECT_SINGLE_SONG_STATEMENT: &'static str = r#"SELECT vorder as "verse_order!", fontSize as "font_size!: i32", backgroundType as "background_type!", horizontalTextAlignment as "horizontal_text_alignment!", verticalTextAlignment as "vertical_text_alignment!", title as "title!", font as "font!", background as "background!", lyrics as "lyrics!", ccli as "ccli!", author as "author!", audio as "audio!", id as "id: i32"  from songs where id = ?"#;
+pub fn get_song(id: i32) -> Result<Song> {
-
-impl SongModelRust {
-    pub fn get_song(id: i32) -> Result<Song> {
     let rt = tokio::runtime::Runtime::new().unwrap();
     let mut db = {
         let mut data = dirs::data_local_dir().unwrap();
@@ -331,12 +419,12 @@ impl SongModelRust {
             SqliteConnection::connect(&db_url).await.expect("problems")
         })
     };
+    debug!("getting song with id: {id}");
     rt.block_on(async {
-            let statement = format!("{} where id = ?", SELECT_SONG_STATEMENT).as_str();
+        let result = query_as!(Song, r#"SELECT vorder as "verse_order!", fontSize as "font_size!: i32", backgroundType as "background_type!", horizontalTextAlignment as "horizontal_text_alignment!", verticalTextAlignment as "vertical_text_alignment!", title as "title!", font as "font!", background as "background!", lyrics as "lyrics!", ccli as "ccli!", author as "author!", audio as "audio!", id as "id: i32"  from songs where id = ?"#, id).fetch_one(&mut db).await?;
-            let result = query_as!(Song, SELECT_SINGLE_SONG_STATEMENT, id).fetch_one(&mut db).await?;
+        debug!(?result);
         Ok(result)
     })
-    }
 }
 
 impl song_model::SongModel {
@@ -1050,90 +1138,7 @@ impl song_model::SongModel {
             return QStringList::default();
         }
         if let Some(song) = self.rust().songs.get(index as usize) {
-            if song.lyrics.is_empty() {
+            lyric_list = song.get_lyric_list();
-                return QStringList::default();
-            }
-            let raw_lyrics = song.lyrics.clone();
-            println!("raw-lyrics: {:?}", raw_lyrics);
-            let vorder: Vec<&str> =
-                song.verse_order.split(' ').collect();
-            let keywords = vec![
-                "Verse 1", "Verse 2", "Verse 3", "Verse 4",
-                "Verse 5", "Verse 6", "Verse 7", "Verse 8",
-                "Chorus 1", "Chorus 2", "Chorus 3", "Chorus 4",
-                "Bridge 1", "Bridge 2", "Bridge 3", "Bridge 4",
-                "Intro 1", "Intro 2", "Ending 1", "Ending 2",
-                "Other 1", "Other 2", "Other 3", "Other 4",
-            ];
-            let _first_item = true;
-
-            let mut lyric_map = HashMap::new();
-            let mut verse_title = String::from("");
-            let mut lyric = String::from("");
-            for (i, line) in raw_lyrics.split('\n').enumerate() {
-                if keywords.contains(&line) {
-                    if i != 0 {
-                        // println!("{verse_title}");
-                        // println!("{lyric}");
-                        lyric_map.insert(verse_title, lyric);
-                        lyric = String::from("");
-                        verse_title = line.to_string();
-                        // println!("{line}");
-                        // println!("\n");
-                    } else {
-                        verse_title = line.to_string();
-                        // println!("{line}");
-                        // println!("\n");
-                    }
-                } else {
-                    lyric.push_str(line);
-                    lyric.push('\n');
-                }
-            }
-            lyric_map.insert(verse_title, lyric);
-            // println!("da-map: {:?}", lyric_map);
-
-            for verse in vorder {
-                let mut verse_name = "";
-                // debug!(verse = verse);
-                for word in keywords.clone() {
-                    let end_verse =
-                        verse.get(1..2).unwrap_or_default();
-                    let beg_verse =
-                        verse.get(0..1).unwrap_or_default();
-                    // println!(
-                    //     "verse: {:?}, beginning: {:?}, end: {:?}, word: {:?}",
-                    //     verse, beg_verse, end_verse, word
-                    // );
-                    if word.starts_with(beg_verse)
-                        && word.ends_with(end_verse)
-                    {
-                        verse_name = word;
-                        // println!("TITLE: {verse_name}");
-                        continue;
-                    }
-                }
-                if let Some(lyric) = lyric_map.get(verse_name) {
-                    if lyric.contains("\n\n") {
-                        let split_lyrics: Vec<&str> =
-                            lyric.split("\n\n").collect();
-                        for lyric in split_lyrics {
-                            if lyric.is_empty() {
-                                continue;
-                            }
-                            lyric_list.append(QString::from(lyric));
-                        }
-                        continue;
-                    }
-                    lyric_list.append(QString::from(lyric));
-                } else {
-                    println!("NOT WORKING!");
-                };
-            }
-            for lyric in lyric_list.iter() {
-                // println!("da-list: {:?}", lyric);
-                debug!(lyric = ?lyric)
-            }
         }
         QStringList::from(&lyric_list)
     }

src/rust/video_model.rs

@@ -194,10 +194,10 @@ use self::video_model::{
 pub struct Video {
     id: i32,
     title: String,
-    path: String,
+    pub path: String,
-    start_time: f32,
+    pub start_time: f32,
-    end_time: f32,
+    pub end_time: f32,
-    looping: bool,
+    pub looping: bool,
 }
 
 #[derive(Debug)]
@@ -231,11 +231,22 @@ impl Default for VideoModelRust {
     }
 }
 
-impl VideoModelRust {
+pub fn get_video(index: i32) -> color_eyre::Result<Video> {
-    pub fn get_video(index: i32) -> Option<&Video> {
+    let rt = tokio::runtime::Runtime::new().unwrap();
-        todo!();
+    let mut db = {
-    }
+        let mut data = dirs::data_local_dir().unwrap();
-
+        data.push("lumina");
+        data.push("library-db.sqlite3");
+        let mut db_url = String::from("sqlite://");
+        db_url.push_str(data.to_str().unwrap());
+        rt.block_on(async {
+            SqliteConnection::connect(&db_url).await.expect("problems")
+        })
+    };
+    rt.block_on(async {
+        let result = query_as!(Video, r#"SELECT id as "id: i32", title as "title!", filePath as "path!", startTime as "start_time!: f32", endTime as "end_time!: f32", loop as "looping!" from videos where id = ?"#, index).fetch_one(&mut db).await?;
+        Ok(result)
+    })
 }
 
 impl video_model::VideoModel {