chore: format rust code

src-tauri/src/core/timer.rs

@@ -8,165 +8,165 @@ use std::collections::HashMap;
 type TaskID = u64;
 
 pub struct Timer {
-  /// cron manager
-  delay_timer: DelayTimer,
+    /// cron manager
+    delay_timer: DelayTimer,
 
-  /// save the current state
-  timer_map: HashMap<String, (TaskID, u64)>,
+    /// save the current state
+    timer_map: HashMap<String, (TaskID, u64)>,
 
-  /// increment id
-  timer_count: TaskID,
+    /// increment id
+    timer_count: TaskID,
 }
 
 impl Timer {
-  pub fn new() -> Self {
-    Timer {
-      delay_timer: DelayTimerBuilder::default().build(),
-      timer_map: HashMap::new(),
-      timer_count: 1,
-    }
-  }
-
-  /// Correctly update all cron tasks
-  pub fn refresh(&mut self) -> Result<()> {
-    let diff_map = self.gen_diff();
-
-    for (uid, diff) in diff_map.into_iter() {
-      match diff {
-        DiffFlag::Del(tid) => {
-          let _ = self.timer_map.remove(&uid);
-          log_if_err!(self.delay_timer.remove_task(tid));
+    pub fn new() -> Self {
+        Timer {
+            delay_timer: DelayTimerBuilder::default().build(),
+            timer_map: HashMap::new(),
+            timer_count: 1,
         }
-        DiffFlag::Add(tid, val) => {
-          let _ = self.timer_map.insert(uid.clone(), (tid, val));
-          log_if_err!(self.add_task(uid, tid, val));
-        }
-        DiffFlag::Mod(tid, val) => {
-          let _ = self.timer_map.insert(uid.clone(), (tid, val));
-          log_if_err!(self.delay_timer.remove_task(tid));
-          log_if_err!(self.add_task(uid, tid, val));
-        }
-      }
     }
 
-    Ok(())
-  }
+    /// Correctly update all cron tasks
+    pub fn refresh(&mut self) -> Result<()> {
+        let diff_map = self.gen_diff();
 
-  /// restore timer
-  pub fn restore(&mut self) -> Result<()> {
-    self.refresh()?;
-
-    let cur_timestamp = get_now(); // seconds
-
-    let global = Data::global();
-    let profiles = global.profiles.lock();
-
-    profiles
-      .get_items()
-      .unwrap_or(&vec![])
-      .iter()
-      .filter(|item| item.uid.is_some() && item.updated.is_some() && item.option.is_some())
-      .filter(|item| {
-        // mins to seconds
-        let interval = item.option.as_ref().unwrap().update_interval.unwrap_or(0) as usize * 60;
-        let updated = item.updated.unwrap();
-        return interval > 0 && cur_timestamp - updated >= interval;
-      })
-      .for_each(|item| {
-        let uid = item.uid.as_ref().unwrap();
-        if let Some((task_id, _)) = self.timer_map.get(uid) {
-          log_if_err!(self.delay_timer.advance_task(*task_id));
+        for (uid, diff) in diff_map.into_iter() {
+            match diff {
+                DiffFlag::Del(tid) => {
+                    let _ = self.timer_map.remove(&uid);
+                    log_if_err!(self.delay_timer.remove_task(tid));
+                }
+                DiffFlag::Add(tid, val) => {
+                    let _ = self.timer_map.insert(uid.clone(), (tid, val));
+                    log_if_err!(self.add_task(uid, tid, val));
+                }
+                DiffFlag::Mod(tid, val) => {
+                    let _ = self.timer_map.insert(uid.clone(), (tid, val));
+                    log_if_err!(self.delay_timer.remove_task(tid));
+                    log_if_err!(self.add_task(uid, tid, val));
+                }
+            }
         }
-      });
 
-    Ok(())
-  }
-
-  /// generate a uid -> update_interval map
-  fn gen_map(&self) -> HashMap<String, u64> {
-    let global = Data::global();
-    let profiles = global.profiles.lock();
-
-    let mut new_map = HashMap::new();
-
-    if let Some(items) = profiles.get_items() {
-      for item in items.iter() {
-        if item.option.is_some() {
-          let option = item.option.as_ref().unwrap();
-          let interval = option.update_interval.unwrap_or(0);
-
-          if interval > 0 {
-            new_map.insert(item.uid.clone().unwrap(), interval);
-          }
-        }
-      }
+        Ok(())
     }
 
-    new_map
-  }
+    /// restore timer
+    pub fn restore(&mut self) -> Result<()> {
+        self.refresh()?;
 
-  /// generate the diff map for refresh
-  fn gen_diff(&mut self) -> HashMap<String, DiffFlag> {
-    let mut diff_map = HashMap::new();
+        let cur_timestamp = get_now(); // seconds
 
-    let new_map = self.gen_map();
-    let cur_map = &self.timer_map;
+        let global = Data::global();
+        let profiles = global.profiles.lock();
 
-    cur_map.iter().for_each(|(uid, (tid, val))| {
-      let new_val = new_map.get(uid).unwrap_or(&0);
+        profiles
+            .get_items()
+            .unwrap_or(&vec![])
+            .iter()
+            .filter(|item| item.uid.is_some() && item.updated.is_some() && item.option.is_some())
+            .filter(|item| {
+                // mins to seconds
+                let interval =
+                    item.option.as_ref().unwrap().update_interval.unwrap_or(0) as usize * 60;
+                let updated = item.updated.unwrap();
+                return interval > 0 && cur_timestamp - updated >= interval;
+            })
+            .for_each(|item| {
+                let uid = item.uid.as_ref().unwrap();
+                if let Some((task_id, _)) = self.timer_map.get(uid) {
+                    log_if_err!(self.delay_timer.advance_task(*task_id));
+                }
+            });
 
-      if *new_val == 0 {
-        diff_map.insert(uid.clone(), DiffFlag::Del(*tid));
-      } else if new_val != val {
-        diff_map.insert(uid.clone(), DiffFlag::Mod(*tid, *new_val));
-      }
-    });
+        Ok(())
+    }
 
-    let mut count = self.timer_count;
+    /// generate a uid -> update_interval map
+    fn gen_map(&self) -> HashMap<String, u64> {
+        let global = Data::global();
+        let profiles = global.profiles.lock();
 
-    new_map.iter().for_each(|(uid, val)| {
-      if cur_map.get(uid).is_none() {
-        diff_map.insert(uid.clone(), DiffFlag::Add(count, *val));
+        let mut new_map = HashMap::new();
 
-        count += 1;
-      }
-    });
+        if let Some(items) = profiles.get_items() {
+            for item in items.iter() {
+                if item.option.is_some() {
+                    let option = item.option.as_ref().unwrap();
+                    let interval = option.update_interval.unwrap_or(0);
 
-    self.timer_count = count;
+                    if interval > 0 {
+                        new_map.insert(item.uid.clone().unwrap(), interval);
+                    }
+                }
+            }
+        }
 
-    diff_map
-  }
+        new_map
+    }
 
-  /// add a cron task
-  fn add_task(&self, uid: String, tid: TaskID, minutes: u64) -> Result<()> {
-    let core = Core::global();
+    /// generate the diff map for refresh
+    fn gen_diff(&mut self) -> HashMap<String, DiffFlag> {
+        let mut diff_map = HashMap::new();
 
-    let task = TaskBuilder::default()
-      .set_task_id(tid)
-      .set_maximum_parallel_runnable_num(1)
-      .set_frequency_repeated_by_minutes(minutes)
-      // .set_frequency_repeated_by_seconds(minutes) // for test
-      .spawn_async_routine(move || Self::async_task(core.to_owned(), uid.to_owned()))
-      .context("failed to create timer task")?;
+        let new_map = self.gen_map();
+        let cur_map = &self.timer_map;
 
-    self
-      .delay_timer
-      .add_task(task)
-      .context("failed to add timer task")?;
+        cur_map.iter().for_each(|(uid, (tid, val))| {
+            let new_val = new_map.get(uid).unwrap_or(&0);
 
-    Ok(())
-  }
+            if *new_val == 0 {
+                diff_map.insert(uid.clone(), DiffFlag::Del(*tid));
+            } else if new_val != val {
+                diff_map.insert(uid.clone(), DiffFlag::Mod(*tid, *new_val));
+            }
+        });
 
-  /// the task runner
-  async fn async_task(core: Core, uid: String) {
-    log::info!(target: "app", "running timer task `{uid}`");
-    log_if_err!(core.update_profile_item(uid, None).await);
-  }
+        let mut count = self.timer_count;
+
+        new_map.iter().for_each(|(uid, val)| {
+            if cur_map.get(uid).is_none() {
+                diff_map.insert(uid.clone(), DiffFlag::Add(count, *val));
+
+                count += 1;
+            }
+        });
+
+        self.timer_count = count;
+
+        diff_map
+    }
+
+    /// add a cron task
+    fn add_task(&self, uid: String, tid: TaskID, minutes: u64) -> Result<()> {
+        let core = Core::global();
+
+        let task = TaskBuilder::default()
+            .set_task_id(tid)
+            .set_maximum_parallel_runnable_num(1)
+            .set_frequency_repeated_by_minutes(minutes)
+            // .set_frequency_repeated_by_seconds(minutes) // for test
+            .spawn_async_routine(move || Self::async_task(core.to_owned(), uid.to_owned()))
+            .context("failed to create timer task")?;
+
+        self.delay_timer
+            .add_task(task)
+            .context("failed to add timer task")?;
+
+        Ok(())
+    }
+
+    /// the task runner
+    async fn async_task(core: Core, uid: String) {
+        log::info!(target: "app", "running timer task `{uid}`");
+        log_if_err!(core.update_profile_item(uid, None).await);
+    }
 }
 
 #[derive(Debug)]
 enum DiffFlag {
-  Del(TaskID),
-  Add(TaskID, u64),
-  Mod(TaskID, u64),
+    Del(TaskID),
+    Add(TaskID, u64),
+    Mod(TaskID, u64),
 }