trying to start moving the functionality to service_item

This would mean that we can use more dependency injection for the
slides instead of the slide needing to figure out which kind of item
to generate and make a slide from.

src/rust/service_item_model.rs

@@ -272,6 +272,8 @@ mod service_item_model {
 }
 
 use crate::service_item_model::service_item_model::QList_QString;
+use crate::songs::song_model::{get_song, Song};
+use crate::{image_model, presentation_model, video_model};
 use cxx_qt::{CxxQtType, Threading};
 use cxx_qt_lib::{
     QByteArray, QModelIndex, QString, QStringList, QUrl, QVariant,
@@ -310,7 +312,7 @@ pub struct ServiceItem {
     looping: bool,
     video_start_time: f32,
     video_end_time: f32,
-    id: i32,
+    database_id: Option<i32>,
 }
 
 impl Default for ServiceItem {
@@ -330,7 +332,7 @@ impl Default for ServiceItem {
             looping: false,
             video_start_time: 0.0,
             video_end_time: 0.0,
-            id: 0,
+            database_id: None,
         }
     }
 }
@@ -407,7 +409,7 @@ impl service_item_model::ServiceItemModel {
         let service_item = ServiceItem {
             name,
             ty: ty.try_into().unwrap(),
-            id,
+            database_id: Some(id),
             ..Default::default()
         };
 
@@ -433,7 +435,7 @@ impl service_item_model::ServiceItemModel {
             self.as_mut().end_insert_rows();
         }
         debug!("ADDING: {:?}", &service_item);
-        self.as_mut().item_added(&service_item.id, &QString::from(&service_item.ty.to_string()));
+        self.as_mut().item_added(&service_item.database_id.unwrap_or_default(), &QString::from(&service_item.ty.to_string()));
     }
 
     pub fn insert_item(
@@ -446,7 +448,7 @@ impl service_item_model::ServiceItemModel {
         let service_item = ServiceItem {
             name,
             ty: ty.try_into().unwrap(),
-            id,
+            database_id: Some(id),
             ..Default::default()
         };
 
@@ -472,7 +474,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, &QString::from(&service_item.ty.to_string()));
+        self.as_mut().item_inserted(&index, &service_item.database_id.unwrap_or_default(), &QString::from(&service_item.ty.to_string()));
     }
 
     pub fn get_item(
@@ -1225,7 +1227,24 @@ impl service_item_model::ServiceItemModel {
                 }
                 let text = QStringList::from(&text_list);
                 if let Ok(ty) = ty.try_into() {
-
+                    match ty {
+                        SlideType::Song => {
+                            let song = Song {
+                                title: name.to_string(),
+                                lyrics: text.to_string(),
+                                audio: audio.to_string(),
+                                font: font.to_string(),
+                                background: background.to_string(),
+                                background_type: background_type.to_string(),
+                                ..Default::default()
+                            };
+                            todo!()
+                        },
+                        SlideType::Video => todo!(),
+                        SlideType::Image => todo!(),
+                        SlideType::Presentation(_) => todo!(),
+                        SlideType::Content => todo!(),
+                    }
                     let service_item = ServiceItem {
                         name,
                         ty,
@@ -1273,6 +1292,47 @@ impl service_item_model::ServiceItemModel {
         }
     }
 
+    fn adding_map(kind: SlideType) -> Result<()> {
+        match kind {
+            SlideType::Song => {
+                let song = get_song(item_model_id)?;
+                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);
+                    },
+                }
+                Ok(())
+            },
+            SlideType::Content => {
+                todo!();
+                Ok(())
+            },
+            SlideType::Presentation(_) => {
+                let presentation = presentation_model::get_presentation(item_model_id)?;
+                let slides = Slide::slides_from_presentation(presentation)?;
+                slides.iter().for_each(|slide| self.as_mut().insert_slide(slide, slide.slide_index + index));
+                Ok(())
+            }
+        }
+    }
+
     fn get_indices(
         self: Pin<&mut Self>,
         item_id: i32,
@@ -1281,7 +1341,7 @@ impl service_item_model::ServiceItemModel {
         let mut vector_roles = QVector_i32::default();
         vector_roles.append(self.as_ref().get_role(role));
         if let Some(index) =
-            self.as_ref().service_items.iter().position(|x| x.id == item_id)
+            self.as_ref().service_items.iter().position(|x| x.database_id.unwrap_or_default() == item_id)
         {
             let model_index = self.as_ref().index(
                 index as i32,
@@ -1374,7 +1434,7 @@ impl service_item_model::ServiceItemModel {
                     QVariant::from(&service_item.video_end_time)
                 }
                 ServiceRoles::Id => {
-                    QVariant::from(&service_item.id)
+                    QVariant::from(&service_item.database_id.unwrap_or_default())
                 }
                 _ => QVariant::default(),
             };