diff --git a/hammond-data/src/utils.rs b/hammond-data/src/utils.rs index ce0aa19..d17ee09 100644 --- a/hammond-data/src/utils.rs +++ b/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> { - let age = age as i32; +fn played_cleaner(cleanup_date: DateTime) -> Result<(), DataError> { 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) -> 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 epoch = now_utc - 200_000; + let cleanup_date = Utc::now() - Duration::seconds(1000); + 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 epoch = now_utc - 20_000; + let cleanup_date = Utc::now() - Duration::seconds(1000); + 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); } diff --git a/hammond-gtk/src/app.rs b/hammond-gtk/src/app.rs index eb236a2..6267a2c 100644 --- a/hammond-gtk/src/app.rs +++ b/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 cleanup_age = utils::get_cleanup_age(&self.settings); + let refresh_interval = utils::get_refresh_interval(&self.settings).num_seconds() as u32; + 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) }); diff --git a/hammond-gtk/src/utils.rs b/hammond-gtk/src/utils.rs index 581cb02..8ecd29c 100644 --- a/hammond-gtk/src/utils.rs +++ b/hammond-gtk/src/utils.rs @@ -22,8 +22,11 @@ use std::thread; use app::Action; -pub fn cleanup(age: u32) { - if let Err(err) = checkup(age) { +use chrono::Duration; +use chrono::prelude::*; + +pub fn cleanup(cleanup_date: DateTime) { + if let Err(err) = checkup(cleanup_date) { error!("Check up failed: {}", err); } } @@ -35,18 +38,19 @@ pub fn refresh(source: Option>, sender: Sender) { } } -pub fn get_refresh_interval(settings: &Settings) -> u32 { - let time = settings.get_int("refresh-interval-time") as u32; +pub fn get_refresh_interval(settings: &Settings) -> Duration { + 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 { - let time = settings.get_int("cleanup-age-time") as u32; +pub fn get_cleanup_date(settings: &Settings) -> DateTime { + 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 { 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, - "days" => time * 86400, - "hours" => time * 3600, - "minutes" => time * 60, - _ => time * 1, + "weeks" => Duration::weeks(time.clone()), + "days" => Duration::days(time.clone()), + "hours" => Duration::hours(time.clone()), + "minutes" => Duration::minutes(time.clone()), + _ => Duration::seconds(time.clone()), } } @@ -177,23 +181,24 @@ mod tests { use hammond_data::dbqueries; #[test] - fn test_time_period_to_seconds() { - let time = 2 as u32; - let week = 604800 * time as u32; - let day = 86400 * time as u32; - let hour = 3600 * time as u32; - let minute = 60 * time as u32; - 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"); + fn test_time_period_to_duration() { + let time = 2; + let week = 604800 * time; + let day = 86400 * time; + let hour = 3600 * time; + let minute = 60 * time; - assert_eq!(week, from_weeks); - assert_eq!(day, from_days); - assert_eq!(hour, from_hours); - assert_eq!(minute, from_minutes); - assert_eq!(time, from_seconds); + assert_eq!(week, time_period_to_duration(&time, "weeks").num_seconds()); + assert_eq!(day, time_period_to_duration(&time, "days").num_seconds()); + assert_eq!(hour, time_period_to_duration(&time, "hours").num_seconds()); + assert_eq!( + minute, + time_period_to_duration(&time, "minutes").num_seconds() + ); + assert_eq!( + time, + time_period_to_duration(&time, "seconds").num_seconds() + ); } #[test]