Use crono types instead of unsigned integers for time periods.

hammond-data/src/utils.rs

@@ -39,10 +39,9 @@ fn download_checker() -> Result<(), DataError> {
 }
 
 /// Delete watched `episodes` that have exceded their liftime after played.
-fn played_cleaner(age: u32) -> Result<(), DataError> {
+fn played_cleaner(cleanup_date: DateTime<Utc>) -> Result<(), DataError> {
-    let age = age as i32;
     let mut episodes = dbqueries::get_played_cleaner_episodes()?;
-    let now_utc = Utc::now().timestamp() as i32 - age;
+    let now_utc = cleanup_date.timestamp() as i32;
 
     episodes
         .par_iter_mut()
@@ -91,10 +90,10 @@ fn delete_local_content(ep: &mut EpisodeCleanerQuery) -> Result<(), DataError> {
 ///
 /// Runs a cleaner for played Episode's that are pass the lifetime limit and
 /// scheduled for removal.
-pub fn checkup(cleanup_age: u32) -> Result<(), DataError> {
+pub fn checkup(cleanup_date: DateTime<Utc>) -> Result<(), DataError> {
     info!("Running database checks.");
     download_checker()?;
-    played_cleaner(cleanup_age)?;
+    played_cleaner(cleanup_date)?;
     info!("Checks completed.");
     Ok(())
 }
@@ -181,6 +180,7 @@ mod tests {
 
     use self::tempdir::TempDir;
     use super::*;
+    use chrono::Duration;
 
     use database::truncate_db;
     use models::NewEpisodeBuilder;
@@ -260,14 +260,14 @@ mod tests {
     fn test_played_cleaner_expired() {
         let _tmp_dir = helper_db();
         let mut episode = dbqueries::get_episode_from_pk("foo_bar", 0).unwrap();
-        let now_utc = Utc::now().timestamp() as i32;
+        let cleanup_date = Utc::now() - Duration::seconds(1000);
-        let epoch = now_utc - 200_000;
+        let epoch = cleanup_date.timestamp() as i32 - 1;
         episode.set_played(Some(epoch));
         episode.save().unwrap();
         let valid_path = episode.local_uri().unwrap().to_owned();
 
         // This should delete the file
-        played_cleaner(172_800).unwrap();
+        played_cleaner(cleanup_date).unwrap();
         assert_eq!(Path::new(&valid_path).exists(), false);
     }
 
@@ -275,14 +275,14 @@ mod tests {
     fn test_played_cleaner_none() {
         let _tmp_dir = helper_db();
         let mut episode = dbqueries::get_episode_from_pk("foo_bar", 0).unwrap();
-        let now_utc = Utc::now().timestamp() as i32;
+        let cleanup_date = Utc::now() - Duration::seconds(1000);
-        let epoch = now_utc - 20_000;
+        let epoch = cleanup_date.timestamp() as i32 + 1;
         episode.set_played(Some(epoch));
         episode.save().unwrap();
         let valid_path = episode.local_uri().unwrap().to_owned();
 
         // This should not delete the file
-        played_cleaner(172_800).unwrap();
+        played_cleaner(cleanup_date).unwrap();
         assert_eq!(Path::new(&valid_path).exists(), true);
     }
 

hammond-gtk/src/app.rs

@@ -106,14 +106,14 @@ impl App {
     fn setup_refresh_on_startup(&self) {
         // Update the feeds right after the Application is initialized.
         if self.settings.get_boolean("refresh-on-startup") {
-            let cleanup_age = utils::get_cleanup_age(&self.settings);
+            let cleanup_date = utils::get_cleanup_date(&self.settings);
             let sender = self.sender.clone();
 
             info!("Refresh on startup.");
 
             gtk::timeout_add_seconds(2, move || {
                 utils::refresh(None, sender.clone());
-                utils::cleanup(cleanup_age);
+                utils::cleanup(cleanup_date);
 
                 glib::Continue(false)
             });
@@ -121,15 +121,15 @@ impl App {
     }
 
     fn setup_auto_refresh(&self) {
-        let refresh_interval = utils::get_refresh_interval(&self.settings);
+        let refresh_interval = utils::get_refresh_interval(&self.settings).num_seconds() as u32;
-        let cleanup_age = utils::get_cleanup_age(&self.settings);
+        let cleanup_date = utils::get_cleanup_date(&self.settings);
         let sender = self.sender.clone();
 
         info!("Auto-refresh every {:?} seconds.", refresh_interval);
 
         gtk::timeout_add_seconds(refresh_interval, move || {
             utils::refresh(None, sender.clone());
-            utils::cleanup(cleanup_age);
+            utils::cleanup(cleanup_date);
 
             glib::Continue(true)
         });

hammond-gtk/src/utils.rs

@@ -22,8 +22,11 @@ use std::thread;
 
 use app::Action;
 
-pub fn cleanup(age: u32) {
+use chrono::Duration;
-    if let Err(err) = checkup(age) {
+use chrono::prelude::*;
+
+pub fn cleanup(cleanup_date: DateTime<Utc>) {
+    if let Err(err) = checkup(cleanup_date) {
         error!("Check up failed: {}", err);
     }
 }
@@ -35,18 +38,19 @@ pub fn refresh(source: Option<Vec<Source>>, sender: Sender<Action>) {
     }
 }
 
-pub fn get_refresh_interval(settings: &Settings) -> u32 {
+pub fn get_refresh_interval(settings: &Settings) -> Duration {
-    let time = settings.get_int("refresh-interval-time") as u32;
+    let time = settings.get_int("refresh-interval-time") as i64;
     let period = settings.get_string("refresh-interval-period").unwrap();
 
-    time_period_to_seconds(&time, period.as_str())
+    time_period_to_duration(&time, period.as_str())
 }
 
-pub fn get_cleanup_age(settings: &Settings) -> u32 {
+pub fn get_cleanup_date(settings: &Settings) -> DateTime<Utc> {
-    let time = settings.get_int("cleanup-age-time") as u32;
+    let time = settings.get_int("cleanup-age-time") as i64;
     let period = settings.get_string("cleanup-age-period").unwrap();
+    let duration = time_period_to_duration(&time, period.as_str());
 
-    time_period_to_seconds(&time, period.as_str())
+    Utc::now() - duration
 }
 
 /// Update the rss feed(s) originating from `source`.
@@ -160,13 +164,13 @@ fn lookup_id(id: u32) -> Result<String, Error> {
     Ok(feedurl.into())
 }
 
-pub fn time_period_to_seconds(time: &u32, period: &str) -> u32 {
+pub fn time_period_to_duration(time: &i64, period: &str) -> Duration {
     match period {
-        "weeks" => time * 604800,
+        "weeks" => Duration::weeks(time.clone()),
-        "days" => time * 86400,
+        "days" => Duration::days(time.clone()),
-        "hours" => time * 3600,
+        "hours" => Duration::hours(time.clone()),
-        "minutes" => time * 60,
+        "minutes" => Duration::minutes(time.clone()),
-        _ => time * 1,
+        _ => Duration::seconds(time.clone()),
     }
 }
 
@@ -177,23 +181,24 @@ mod tests {
     use hammond_data::dbqueries;
 
     #[test]
-    fn test_time_period_to_seconds() {
+    fn test_time_period_to_duration() {
-        let time = 2 as u32;
+        let time = 2;
-        let week = 604800 * time as u32;
+        let week = 604800 * time;
-        let day = 86400 * time as u32;
+        let day = 86400 * time;
-        let hour = 3600 * time as u32;
+        let hour = 3600 * time;
-        let minute = 60 * time as u32;
+        let minute = 60 * time;
-        let from_weeks = time_period_to_seconds(&time, "weeks");
-        let from_days = time_period_to_seconds(&time, "days");
-        let from_hours = time_period_to_seconds(&time, "hours");
-        let from_minutes = time_period_to_seconds(&time, "minutes");
-        let from_seconds = time_period_to_seconds(&time, "seconds");
 
-        assert_eq!(week, from_weeks);
+        assert_eq!(week, time_period_to_duration(&time, "weeks").num_seconds());
-        assert_eq!(day, from_days);
+        assert_eq!(day, time_period_to_duration(&time, "days").num_seconds());
-        assert_eq!(hour, from_hours);
+        assert_eq!(hour, time_period_to_duration(&time, "hours").num_seconds());
-        assert_eq!(minute, from_minutes);
+        assert_eq!(
-        assert_eq!(time, from_seconds);
+            minute,
+            time_period_to_duration(&time, "minutes").num_seconds()
+        );
+        assert_eq!(
+            time,
+            time_period_to_duration(&time, "seconds").num_seconds()
+        );
     }
 
     #[test]