toxblh/podcasts
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Use crono types instead of unsigned integers for time periods.

Browse Source
This commit is contained in:
Rowan Lewis 2018-03-17 01:10:10 +01:00
parent 69a7a9b180
commit afdedc7575
3 changed files with 51 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
hammond-data/src/utils.rs
View File

@ -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<Utc>) -> 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<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 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);
}

10
hammond-gtk/src/app.rs
View File

@ -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)
});

65
hammond-gtk/src/utils.rs
View File

@ -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<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 {
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<Utc> {
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,
"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]