Allow uploading from person editor

musicus/res/ui/person_editor.ui

@@ -8,6 +8,11 @@
     <property name="modal">True</property>
     <property name="destroy-with-parent">True</property>
     <property name="type-hint">dialog</property>
+    <child>
+      <object class="GtkStack" id="stack">
+        <property name="visible">True</property>
+        <property name="can-focus">False</property>
+        <property name="transition-type">crossfade</property>
         <child>
           <object class="GtkBox">
             <property name="visible">True</property>
@@ -49,7 +54,7 @@
               </packing>
             </child>
             <child>
-          <!-- n-columns=2 n-rows=2 -->
+              <!-- n-columns=2 n-rows=3 -->
               <object class="GtkGrid">
                 <property name="visible">True</property>
                 <property name="can-focus">False</property>
@@ -102,6 +107,83 @@
                     <property name="top-attach">1</property>
                   </packing>
                 </child>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="halign">end</property>
+                    <property name="label" translatable="yes">Publish</property>
+                  </object>
+                  <packing>
+                    <property name="left-attach">0</property>
+                    <property name="top-attach">2</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkSwitch" id="upload_switch">
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <property name="halign">start</property>
+                    <property name="active">True</property>
+                  </object>
+                  <packing>
+                    <property name="left-attach">1</property>
+                    <property name="top-attach">2</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkInfoBar" id="info_bar">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="revealed">False</property>
+                <child internal-child="action_area">
+                  <object class="GtkButtonBox">
+                    <property name="can-focus">False</property>
+                    <property name="spacing">6</property>
+                    <property name="layout-style">end</property>
+                    <child>
+                      <placeholder/>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">False</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child internal-child="content_area">
+                  <object class="GtkBox">
+                    <property name="can-focus">False</property>
+                    <property name="spacing">16</property>
+                    <child>
+                      <object class="GtkLabel">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">Failed to save person!</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">False</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <placeholder/>
+                </child>
               </object>
               <packing>
                 <property name="expand">False</property>
@@ -110,6 +192,47 @@
               </packing>
             </child>
           </object>
+          <packing>
+            <property name="name">content</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="orientation">vertical</property>
+            <child>
+              <object class="HdyHeaderBar">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="title" translatable="yes">Person</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkSpinner">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="vexpand">True</property>
+                <property name="active">True</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="name">loading</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
     </child>
   </object>
 </interface>

musicus/src/backend/client/mod.rs

@@ -5,6 +5,7 @@ use gio::prelude::*;
 use isahc::http::StatusCode;
 use isahc::prelude::*;
 use serde::Serialize;
+use std::time::Duration;
 
 pub mod persons;
 pub use persons::*;
@@ -64,6 +65,7 @@ impl Backend {
     pub async fn set_login_data(&self, data: LoginData) -> Result<()> {
         secure::store_login_data(data.clone()).await?;
         self.login_data.replace(Some(data));
+        self.token.replace(None);
         Ok(())
     }
 
@@ -82,7 +84,6 @@ impl Backend {
             StatusCode::OK => {
                 let token = response.text_async().await?;
                 self.set_token(&token);
-                println!("{}", &token);
                 true
             }
             StatusCode::UNAUTHORIZED => false,
@@ -91,4 +92,65 @@ impl Backend {
 
         Ok(success)
     }
+
+    /// Make an unauthenticated get request to the server.
+    async fn get(&self, url: &str) -> Result<String> {
+        let server_url = self.get_server_url().ok_or(anyhow!("No server URL set!"))?;
+
+        let mut response = Request::get(format!("{}/{}", server_url, url))
+            .timeout(Duration::from_secs(10))
+            .body(())?
+            .send_async()
+            .await?;
+
+        let body = response.text_async().await?;
+
+        Ok(body)
+    }
+
+    /// Make an authenticated post request to the server.
+    async fn post(&self, url: &str, body: String) -> Result<String> {
+        let body = match self.get_token() {
+            Some(_) => {
+                let mut response = self.post_priv(url, body.clone()).await?;
+
+                // Try one more time (maybe the token was expired)
+                if response.status() == StatusCode::UNAUTHORIZED {
+                    if self.login().await? {
+                        response = self.post_priv(url, body).await?;
+                    } else {
+                        bail!("Login failed!");
+                    }
+                }
+
+                response.text_async().await?
+            }
+            None => {
+                let mut response = if self.login().await? {
+                    self.post_priv(url, body).await?
+                } else {
+                    bail!("Login failed!");
+                };
+
+                response.text_async().await?
+            }
+        };
+
+        Ok(body)
+    }
+
+    /// Post something to the server assuming there is a valid login token.
+    async fn post_priv(&self, url: &str, body: String) -> Result<Response<Body>> {
+        let server_url = self.get_server_url().ok_or(anyhow!("No server URL set!"))?;
+        let token = self.get_token().ok_or(anyhow!("No login token!"))?;
+
+        let response = Request::post(format!("{}/{}", server_url, url))
+            .header("Authorization", format!("Bearer {}", token))
+            .header("Content-Type", "application/json")
+            .body(body)?
+            .send_async()
+            .await?;
+
+        Ok(response)
+    }
 }

musicus/src/backend/client/persons.rs

@@ -1,24 +1,18 @@
 use super::Backend;
 use crate::database::Person;
-use anyhow::{anyhow, Result};
+use anyhow::Result;
-use isahc::prelude::*;
-use std::time::Duration;
 
 impl Backend {
     /// Get all available persons from the server.
     pub async fn get_persons(&self) -> Result<Vec<Person>> {
-        let server_url = self.get_server_url().ok_or(anyhow!("No server URL set!"))?;
+        let body = self.get("persons").await?;
-
-        let mut response = Request::get(format!("{}/persons", server_url))
-            .timeout(Duration::from_secs(10))
-            .body(())?
-            .send_async()
-            .await?;
-
-        let body = response.text_async().await?;
-
         let persons: Vec<Person> = serde_json::from_str(&body)?;
-
         Ok(persons)
     }
+
+    /// Post a new person to the server and return the ID.
+    pub async fn post_person(&self, data: &Person) -> Result<()> {
+        self.post("persons", serde_json::to_string(data)?).await?;
+        Ok(())
+    }
 }

musicus/src/backend/library.rs

@@ -30,6 +30,10 @@ impl Backend {
     pub async fn set_music_library_path_priv(&self, path: PathBuf) -> Result<()> {
         self.set_state(BackendState::Loading);
 
+        if let Some(db) = &*self.database.borrow() {
+            db.stop().await?;
+        }
+
         self.music_library_path.replace(Some(path.clone()));
 
         let mut db_path = path.clone();
@@ -66,6 +70,12 @@ impl Backend {
         self.player.borrow().clone()
     }
 
+    /// Notify the frontend that the library was changed.
+    pub fn library_changed(&self) {
+        self.set_state(BackendState::Loading);
+        self.set_state(BackendState::Ready);
+    }
+
     /// Get an interface to the player and panic if there is none.
     pub fn pl(&self) -> Rc<Player> {
         self.get_player().unwrap()

musicus/src/database/recordings.rs

@@ -2,9 +2,7 @@ use super::schema::{ensembles, performances, persons, recordings};
 use super::{Database, Ensemble, Instrument, Person, Work};
 use anyhow::{anyhow, Error, Result};
 use diesel::prelude::*;
-use diesel::{Insertable, Queryable};
 use serde::{Deserialize, Serialize};
-use std::convert::TryInto;
 
 /// Database table data for a recording.
 #[derive(Insertable, Queryable, Debug, Clone)]

musicus/src/dialogs/person_editor.rs

@@ -1,85 +1,129 @@
 use crate::backend::Backend;
 use crate::database::*;
+use anyhow::Result;
 use glib::clone;
 use gtk::prelude::*;
 use gtk_macros::get_widget;
+use std::cell::RefCell;
 use std::rc::Rc;
 
-pub struct PersonEditor<F>
+/// A dialog for creating or editing a person.
-where
+pub struct PersonEditor {
-    F: Fn(Person) -> () + 'static,
-{
     backend: Rc<Backend>,
     id: String,
     window: libhandy::Window,
-    callback: F,
+    stack: gtk::Stack,
-    id: u32,
+    info_bar: gtk::InfoBar,
     first_name_entry: gtk::Entry,
     last_name_entry: gtk::Entry,
+    upload_switch: gtk::Switch,
+    saved_cb: RefCell<Option<Box<dyn Fn(Person) -> ()>>>,
 }
 
-impl<F> PersonEditor<F>
+impl PersonEditor {
-where
+    /// Create a new person editor and optionally initialize it.
-    F: Fn(Person) -> () + 'static,
-{
     pub fn new<P: IsA<gtk::Window>>(
         backend: Rc<Backend>,
         parent: &P,
         person: Option<Person>,
-        callback: F,
     ) -> Rc<Self> {
+        // Create UI
+
         let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/person_editor.ui");
 
         get_widget!(builder, libhandy::Window, window);
         get_widget!(builder, gtk::Button, cancel_button);
         get_widget!(builder, gtk::Button, save_button);
+        get_widget!(builder, gtk::Stack, stack);
+        get_widget!(builder, gtk::InfoBar, info_bar);
         get_widget!(builder, gtk::Entry, first_name_entry);
         get_widget!(builder, gtk::Entry, last_name_entry);
+        get_widget!(builder, gtk::Switch, upload_switch);
 
         let id = match person {
             Some(person) => {
                 first_name_entry.set_text(&person.first_name);
                 last_name_entry.set_text(&person.last_name);
+
                 person.id
             }
-            None => rand::random::<u32>().into(),
+            None => generate_id(),
         };
 
-        let result = Rc::new(PersonEditor {
+        let this = Rc::new(Self {
-            backend: backend,
+            backend,
-            window: window,
+            id,
-            callback: callback,
+            window,
-            id: id,
+            stack,
-            first_name_entry: first_name_entry,
+            info_bar,
-            last_name_entry: last_name_entry,
+            first_name_entry,
+            last_name_entry,
+            upload_switch,
+            saved_cb: RefCell::new(None),
         });
 
-        cancel_button.connect_clicked(clone!(@strong result => move |_| {
+        // Connect signals and callbacks
-            result.window.close();
+
+        cancel_button.connect_clicked(clone!(@strong this => move |_| {
+            this.window.close();
         }));
 
-        save_button.connect_clicked(clone!(@strong result => move |_| {
+        save_button.connect_clicked(clone!(@strong this => move |_| {
-            let person = Person {
+            let context = glib::MainContext::default();
-                id: result.id,
+            let clone = this.clone();
-                first_name: result.first_name_entry.get_text().to_string(),
+            context.spawn_local(async move {
-                last_name: result.last_name_entry.get_text().to_string(),
+                clone.stack.set_visible_child_name("loading");
-            };
+                match clone.clone().save().await {
-
+                    Ok(_) => {
-            let c = glib::MainContext::default();
-            let clone = result.clone();
-            c.spawn_local(async move {
-                clone.backend.db().update_person(person.clone()).await.unwrap();
                         clone.window.close();
-                (clone.callback)(person.clone());
+                    }
-            });
+                    Err(_) => {
-        }));
+                        clone.info_bar.set_revealed(true);
-
+                        clone.stack.set_visible_child_name("content");
-        result.window.set_transient_for(Some(parent));
+                    }
-
-        result
                 }
 
+            });
+        }));
+
+        this.window.set_transient_for(Some(parent));
+
+        this
+    }
+
+    /// Set the closure to be called if the person was saved.
+    pub fn set_saved_cb<F: Fn(Person) -> () + 'static>(&self, cb: F) {
+        self.saved_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Show the person editor.
     pub fn show(&self) {
         self.window.show();
     }
+
+    /// Save the person and possibly upload it to the server.
+    async fn save(self: Rc<Self>) -> Result<()> {
+        let first_name = self.first_name_entry.get_text().to_string();
+        let last_name = self.last_name_entry.get_text().to_string();
+
+        let person = Person {
+            id: self.id.clone(),
+            first_name,
+            last_name,
+        };
+
+        let upload = self.upload_switch.get_active();
+        if upload {
+            self.backend.post_person(&person).await?;
+        }
+
+        self.backend.db().update_person(person.clone()).await?;
+        self.backend.library_changed();
+
+        if let Some(cb) = &*self.saved_cb.borrow() {
+            cb(person.clone());
+        }
+
+        Ok(())
+    }
 }

musicus/src/dialogs/person_selector.rs

@@ -58,14 +58,15 @@ impl PersonSelector {
                 this.backend.clone(),
                 &this.window,
                 None,
-                clone!(@strong this => move |person| {
+            );
+
+            editor.set_saved_cb(clone!(@strong this => move |person| {
                 if let Some(cb) = &*this.selected_cb.borrow() {
                     cb(person);
                 }
 
                 this.window.close();
-                }),
+            }));
-            );
 
             editor.show();
         }));