database persistence in progress

src/scheduler.rs

@@ -2,24 +2,31 @@ use std::sync::{Arc, Mutex};
 
 use chrono::{DateTime, Local, Timelike};
 use cron_tab::Cron;
+use sea_orm::DatabaseConnection;
 
+use crate::dao::alarm::create_alarm;
 use crate::ringer::Ringer;
 use crate::types::Alarm;
 
-
 #[derive(Debug)]
 pub struct Scheduler<T: Ringer + 'static> {
     ringer: Arc<Mutex<T>>,
     cron: Arc<Mutex<Cron<Local>>>,
     alarms: Arc<Mutex<Vec<Alarm>>>,
+    db: Arc<DatabaseConnection>,
 }
 
 impl<T: Ringer> Scheduler<T> {
-    pub fn new(ringer: Arc<Mutex<T>>, cron: Arc<Mutex<Cron<Local>>>) -> Self {
+    pub fn new(
+        ringer: Arc<Mutex<T>>,
+        cron: Arc<Mutex<Cron<Local>>>,
+        db: Arc<DatabaseConnection>,
+    ) -> Self {
         Self {
             ringer,
             cron,
             alarms: Arc::new(Mutex::new(Vec::new())),
+            db,
         }
     }
 
@@ -41,12 +48,15 @@ impl<T: Ringer> Scheduler<T> {
         todo!()
     }
 
-    pub fn add_alarm(&self, time: DateTime<Local>) -> Result<Alarm, String> {
-        let mut alarms = self.alarms.lock().map_err(|e| e.to_string())?;
+    pub async fn add_alarm(&self, time: DateTime<Local>) -> Result<Alarm, String> {
         let cron_schedule = format!("{} {} {} * * *", "*", time.minute(), time.hour());
-		let alarm = Alarm::new(true, time);
-        alarms.push(alarm.clone());
-		self.schedule(&cron_schedule).map_err(|e| e.to_string())?;
+        let alarm = Alarm::new(true, time);
+
+        create_alarm(&*self.db, "something", time)
+            .await
+            .map_err(|e| e.to_string())?;
+
+        self.schedule(&cron_schedule).map_err(|e| e.to_string())?;
         println!("Added alarm {}", cron_schedule);
 
         Ok(alarm)