Accept a full secret address for advanced connection

This should make it a bit easier to test, because you don't need to copy
the individual parts of the secret address.

Author: blinry

src/services/node_service.rs

@@ -62,17 +62,14 @@ pub struct SecretAddress {
 }
 
 impl SecretAddress {
-    pub fn from_string(peer_node_id: String, peer_passphrase: String) -> Result<Self> {
-        if peer_node_id.is_empty() {
-            bail!("peer_node_id is empty!")
+    pub fn from_string(peer_secret_address: String) -> Result<Self> {
+        let parts: Vec<&str> = peer_secret_address.split('#').collect();
+        if parts.len() != 2 {
+            bail!("peer_secret_address does not have the format <node_id>#<passphrase>")
         }
 
-        if peer_passphrase.is_empty() {
-            bail!("peer_passphrase is empty!")
-        }
-
-        let peer_node_id = NodeId::from_str(&peer_node_id)?;
-        let peer_passphrase = SecretKey::from_str(&peer_passphrase)?;
+        let peer_node_id = NodeId::from_str(&parts[0])?;
+        let peer_passphrase = SecretKey::from_str(&parts[1])?;
 
         Ok(Self {
             peer_node_id,
@@ -173,14 +170,8 @@ pub async fn get_secret_address_from_wormhole(code: &str) -> Result<SecretAddres
         MailboxConnection::connect(config, Code::from_str(code)?, false).await?;
     let mut wormhole = Wormhole::connect(mailbox_connection).await?;
     let bytes = wormhole.receive().await?;
-    let fragments: Vec<String> = String::from_utf8(bytes)?
-        .clone()
-        .split("#")
-        .map(|value| value.to_string())
-        .collect();
-    let peer_node_id = fragments[0].to_string();
-    let peer_passphrase = fragments[1].to_string();
-    SecretAddress::from_string(peer_node_id, peer_passphrase)
+    let secret_address = String::from_utf8(bytes)?;
+    SecretAddress::from_string(secret_address)
 }
 
 async fn handle_node_command(

src/ui/connection_form.rs

@@ -25,27 +25,14 @@ fn AdvancedForm() -> Element {
     rsx! {
         fieldset {
             label {
-                for: "peer_node_id",
-                "peer node id:"
-            }
-
-            input {
-                id: "peer_node_id",
-                name: "peer_node_id",
-                style: "min-width: 40em;"
-            }
-        }
-
-        fieldset {
-            label {
-                for: "peer_passphrase",
-                "peer passphrase:"
+                for: "peer_secret_address",
+                "peer's secret address:"
             }
 
             // TODO: should this be type: password?
             input {
-                id: "peer_passphrase",
-                name: "peer_passphrase",
+                id: "peer_secret_address",
+                name: "peer_secret_address",
                 style: "min-width: 40em;"
             }
         }
@@ -54,13 +41,12 @@ fn AdvancedForm() -> Element {
 
 #[derive(Default)]
 struct SimpleFormData {
-    join_code: String
+    join_code: String,
 }
 
 #[derive(Default)]
 struct AdvancedFormData {
-    peer_node_id: String,
-    peer_passphrase: String
+    peer_secret_address: String,
 }
 
 #[component]
@@ -83,9 +69,8 @@ pub fn ConnectionForm() -> Element {
                 node_service.send(NodeCommand::ConnectByJoinCode { join_code });
             }
             "advanced" => {
-                let peer_node_id = advanced_form_data.read().peer_node_id.clone();
-                let peer_passphrase = advanced_form_data.read().peer_passphrase.clone();
-                match SecretAddress::from_string(peer_node_id, peer_passphrase) {
+                let peer_secret_address = advanced_form_data.read().peer_secret_address.clone();
+                match SecretAddress::from_string(peer_secret_address) {
                     Ok(secret_address) => node_service.send(NodeCommand::ConnectByAddress {
                         secret_address: Box::new(secret_address),
                     }),