diff --git a/Cargo.toml b/Cargo.toml index 4434a10..c4c9629 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,3 +4,6 @@ members = [ "hammond-downloader", "hammond-gtk" ] + +[profile.release] +debug = true diff --git a/hammond-data/src/dbqueries.rs b/hammond-data/src/dbqueries.rs index bd726d5..3d6fc23 100644 --- a/hammond-data/src/dbqueries.rs +++ b/hammond-data/src/dbqueries.rs @@ -34,6 +34,23 @@ pub fn get_episodes(con: &SqliteConnection) -> QueryResult> { eps } +pub fn get_episode(con: &SqliteConnection, ep_id: i32) -> QueryResult { + use schema::episode::dsl::*; + + let ep = episode.filter(id.eq(ep_id)).get_result::(con); + ep +} + +pub fn get_episode_local_uri(con: &SqliteConnection, ep_id: i32) -> QueryResult> { + use schema::episode::dsl::*; + + let ep = episode + .filter(id.eq(ep_id)) + .select(local_uri) + .get_result::>(con); + ep +} + pub fn get_episodes_with_limit(con: &SqliteConnection, limit: u32) -> QueryResult> { use schema::episode::dsl::*; @@ -73,21 +90,21 @@ pub fn get_pd_episodes_limit( eps } -pub fn load_source(con: &SqliteConnection, uri_: &str) -> QueryResult { +pub fn load_source_from_uri(con: &SqliteConnection, uri_: &str) -> QueryResult { use schema::source::dsl::*; let s = source.filter(uri.eq(uri_)).get_result::(con); s } -pub fn load_podcast(con: &SqliteConnection, title_: &str) -> QueryResult { +pub fn load_podcast_from_title(con: &SqliteConnection, title_: &str) -> QueryResult { use schema::podcast::dsl::*; let pd = podcast.filter(title.eq(title_)).get_result::(con); pd } -pub fn load_episode(con: &SqliteConnection, uri_: &str) -> QueryResult { +pub fn load_episode_from_uri(con: &SqliteConnection, uri_: &str) -> QueryResult { use schema::episode::dsl::*; let ep = episode.filter(uri.eq(uri_)).get_result::(con); diff --git a/hammond-data/src/index_feed.rs b/hammond-data/src/index_feed.rs index 64589f1..8b8cf40 100644 --- a/hammond-data/src/index_feed.rs +++ b/hammond-data/src/index_feed.rs @@ -18,7 +18,7 @@ use feedparser; pub struct Feed(pub reqwest::Response, pub Source); fn index_source(con: &SqliteConnection, foo: &NewSource) -> Result<()> { - match dbqueries::load_source(con, foo.uri) { + match dbqueries::load_source_from_uri(con, foo.uri) { Ok(_) => Ok(()), Err(_) => { diesel::insert(foo).into(schema::source::table).execute(con)?; @@ -28,7 +28,7 @@ fn index_source(con: &SqliteConnection, foo: &NewSource) -> Result<()> { } fn index_podcast(con: &SqliteConnection, pd: &NewPodcast) -> Result<()> { - match dbqueries::load_podcast(con, &pd.title) { + match dbqueries::load_podcast_from_title(con, &pd.title) { Ok(mut foo) => if foo.link() != pd.link || foo.description() != pd.description { foo.set_link(&pd.link); foo.set_description(&pd.description); @@ -43,7 +43,7 @@ fn index_podcast(con: &SqliteConnection, pd: &NewPodcast) -> Result<()> { } fn index_episode(con: &SqliteConnection, ep: &NewEpisode) -> Result<()> { - match dbqueries::load_episode(con, ep.uri.unwrap()) { + match dbqueries::load_episode_from_uri(con, ep.uri.unwrap()) { Ok(mut foo) => if foo.title() != ep.title || foo.published_date() != ep.published_date.as_ref().map(|x| x.as_str()) { @@ -66,19 +66,19 @@ pub fn insert_return_source(con: &SqliteConnection, url: &str) -> Result let foo = NewSource::new_with_uri(url); index_source(con, &foo)?; - Ok(dbqueries::load_source(con, foo.uri)?) + Ok(dbqueries::load_source_from_uri(con, foo.uri)?) } fn insert_return_podcast(con: &SqliteConnection, pd: &NewPodcast) -> Result { index_podcast(con, pd)?; - Ok(dbqueries::load_podcast(con, &pd.title)?) + Ok(dbqueries::load_podcast_from_title(con, &pd.title)?) } fn insert_return_episode(con: &SqliteConnection, ep: &NewEpisode) -> Result { index_episode(con, ep)?; - Ok(dbqueries::load_episode(con, ep.uri.unwrap())?) + Ok(dbqueries::load_episode_from_uri(con, ep.uri.unwrap())?) } pub fn index_loop(db: &Arc>, force: bool) -> Result<()> { diff --git a/hammond-gtk/src/widgets/episode.rs b/hammond-gtk/src/widgets/episode.rs index d852363..343076e 100644 --- a/hammond-gtk/src/widgets/episode.rs +++ b/hammond-gtk/src/widgets/episode.rs @@ -59,19 +59,17 @@ fn epidose_widget( } if episode.local_uri().is_some() { - let uri = episode.local_uri().unwrap().to_owned(); + dl_button.hide(); + play_button.show(); + }; - if Path::new(&uri).exists() { - dl_button.hide(); - play_button.show(); - play_button.connect_clicked(move |_| { - let e = open::that(&uri); - if e.is_err() { - error!("Error while trying to open: {}", uri); - } - }); - } - } + let ep_clone = episode.clone(); + let db = connection.clone(); + let play_button_clone = play_button.clone(); + play_button.connect_clicked(move |_| { + // info!("I RUN"); + on_play_bttn_clicked(&db, ep_clone.id(), &play_button_clone); + }); // TODO: figure out how to use the gtk-clone macro, // to make it less tedious. @@ -124,6 +122,34 @@ fn on_dl_clicked( }); } +fn on_play_bttn_clicked( + db: &Arc>, + episode_id: i32, + play_button: >k::Button, +) { + let local_uri = { + let tempdb = db.lock().unwrap(); + dbqueries::get_episode_local_uri(&tempdb, episode_id).unwrap() + }; + + info!("Local_uri: {:?}", local_uri); + if local_uri.is_some() { + let uri = local_uri.unwrap().to_owned(); + + if Path::new(&uri).exists() { + play_button.show(); + play_button.connect_clicked(move |_| { + let e = open::that(&uri); + if e.is_err() { + error!("Error while trying to open: {}", uri); + } + }); + } else { + () + } + } +} + fn receive() -> glib::Continue { GLOBAL.with(|global| { if let Some((ref dl_bttn, ref play_bttn, ref reciever)) = *global.borrow() { @@ -139,7 +165,7 @@ fn receive() -> glib::Continue { pub fn episodes_listbox(connection: &Arc>, pd_title: &str) -> gtk::ListBox { // TODO: handle unwraps. let m = connection.lock().unwrap(); - let pd = dbqueries::load_podcast(&m, pd_title).unwrap(); + let pd = dbqueries::load_podcast_from_title(&m, pd_title).unwrap(); let mut episodes = dbqueries::get_pd_episodes(&m, &pd).unwrap(); drop(m);