Fixed a play button bug.

The local_uri value for the play button was assigned at parent widget evaluation,
instead when being clicked, and so when downloading something it would not be able
to open the file without reloading the parent widget and refreshing the value.

Cargo.toml

@@ -4,3 +4,6 @@ members = [
     "hammond-downloader",
     "hammond-gtk"
 ]
+
+[profile.release]
+debug = true

hammond-data/src/dbqueries.rs

@@ -34,6 +34,23 @@ pub fn get_episodes(con: &SqliteConnection) -> QueryResult<Vec<Episode>> {
     eps
 }
 
+pub fn get_episode(con: &SqliteConnection, ep_id: i32) -> QueryResult<Episode> {
+    use schema::episode::dsl::*;
+
+    let ep = episode.filter(id.eq(ep_id)).get_result::<Episode>(con);
+    ep
+}
+
+pub fn get_episode_local_uri(con: &SqliteConnection, ep_id: i32) -> QueryResult<Option<String>> {
+    use schema::episode::dsl::*;
+
+    let ep = episode
+        .filter(id.eq(ep_id))
+        .select(local_uri)
+        .get_result::<Option<String>>(con);
+    ep
+}
+
 pub fn get_episodes_with_limit(con: &SqliteConnection, limit: u32) -> QueryResult<Vec<Episode>> {
     use schema::episode::dsl::*;
 
@@ -73,21 +90,21 @@ pub fn get_pd_episodes_limit(
     eps
 }
 
-pub fn load_source(con: &SqliteConnection, uri_: &str) -> QueryResult<Source> {
+pub fn load_source_from_uri(con: &SqliteConnection, uri_: &str) -> QueryResult<Source> {
     use schema::source::dsl::*;
 
     let s = source.filter(uri.eq(uri_)).get_result::<Source>(con);
     s
 }
 
-pub fn load_podcast(con: &SqliteConnection, title_: &str) -> QueryResult<Podcast> {
+pub fn load_podcast_from_title(con: &SqliteConnection, title_: &str) -> QueryResult<Podcast> {
     use schema::podcast::dsl::*;
 
     let pd = podcast.filter(title.eq(title_)).get_result::<Podcast>(con);
     pd
 }
 
-pub fn load_episode(con: &SqliteConnection, uri_: &str) -> QueryResult<Episode> {
+pub fn load_episode_from_uri(con: &SqliteConnection, uri_: &str) -> QueryResult<Episode> {
     use schema::episode::dsl::*;
 
     let ep = episode.filter(uri.eq(uri_)).get_result::<Episode>(con);

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<Source>
     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<Podcast> {
     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<Episode> {
     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<Mutex<SqliteConnection>>, force: bool) -> Result<()> {

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<Mutex<SqliteConnection>>,
+    episode_id: i32,
+    play_button: &gtk::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<Mutex<SqliteConnection>>, 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);