More logging, delete, new convo

core/kpcli/src/client/mod.rs

@@ -5,10 +5,10 @@ use kordophone::api::InMemoryAuthenticationStore;
 use kordophone::APIInterface;
 
 use crate::printers::{ConversationPrinter, MessagePrinter};
-use anyhow::Result;
+use anyhow::{bail, Result};
 use clap::Subcommand;
 use kordophone::model::event::EventData;
-use kordophone::model::outgoing_message::OutgoingMessage;
+use kordophone::model::{HandleResolutionStatus, OutgoingMessage, OutgoingMessageTarget};
 
 use futures_util::StreamExt;
 
@@ -47,14 +47,29 @@ pub enum Commands {
     /// Prints all raw updates from the server.
     RawUpdates,
 
-    /// Sends a message to the server.
-    SendMessage {
+    /// Resolves an address to a canonical handle.
+    #[command(alias = "resolve")]
+    ResolveHandle { address: String },
+
+    /// Replies to an existing conversation.
+    #[command(alias = "send-message")]
+    Reply {
         conversation_id: String,
         message: String,
     },
 
+    /// Starts a new message to one or more resolved handles.
+    New {
+        #[arg(long = "handle", required = true)]
+        handle_ids: Vec<String>,
+        message: String,
+    },
+
     /// Marks a conversation as read.
     Mark { conversation_id: String },
+
+    /// Deletes a conversation from the server.
+    Delete { conversation_id: String },
 }
 
 impl Commands {
@@ -66,13 +81,19 @@ impl Commands {
             Commands::Messages { conversation_id } => client.print_messages(conversation_id).await,
             Commands::RawUpdates => client.print_raw_updates().await,
             Commands::Events => client.print_events().await,
-            Commands::SendMessage {
+            Commands::ResolveHandle { address } => client.resolve_handle(address).await,
+            Commands::Reply {
                 conversation_id,
                 message,
-            } => client.send_message(conversation_id, message).await,
+            } => client.reply(conversation_id, message).await,
+            Commands::New {
+                handle_ids,
+                message,
+            } => client.new_message(handle_ids, message).await,
             Commands::Mark { conversation_id } => {
                 client.mark_conversation_as_read(conversation_id).await
             }
+            Commands::Delete { conversation_id } => client.delete_conversation(conversation_id).await,
         }
     }
 }
@@ -167,20 +188,92 @@ impl ClientCli {
         Ok(())
     }
 
-    pub async fn send_message(&mut self, conversation_id: String, message: String) -> Result<()> {
+    pub async fn resolve_handle(&mut self, address: String) -> Result<()> {
+        let response = self.api.resolve_handle(&address).await?;
+        let status = match response.status {
+            HandleResolutionStatus::Valid => "valid",
+            HandleResolutionStatus::Invalid => "invalid",
+            HandleResolutionStatus::Unknown => "unknown",
+        };
+
+        println!("Resolved handle: {}", response.resolved_handle.id);
+
+        if let Some(name) = response.resolved_handle.name {
+            println!("Name: {}", name);
+        }
+
+        println!("Status: {}", status);
+
+        if let Some(conversation_id) = response.existing_chat {
+            println!("Existing conversation: {}", conversation_id);
+        }
+
+        Ok(())
+    }
+
+    async fn send_message(
+        &mut self,
+        target: OutgoingMessageTarget,
+        message: String,
+    ) -> Result<()> {
         let outgoing_message = OutgoingMessage::builder()
-            .conversation_id(conversation_id)
+            .target(target)
             .text(message)
             .build();
 
         let response = self.api.send_message(&outgoing_message).await?;
-        println!("Message sent: {}", response.message.guid);
+        if let Some(conversation_id) = response.conversation_id {
+            println!(
+                "Message sent: {} conversation: {}",
+                response.message.guid, conversation_id
+            );
+        } else {
+            println!("Message sent: {}", response.message.guid);
+        }
         Ok(())
     }
 
+    async fn resolve_handle_ids(&mut self, handle_ids: Vec<String>) -> Result<Vec<String>> {
+        let mut resolved_handle_ids = Vec::with_capacity(handle_ids.len());
+
+        for handle_id in handle_ids {
+            let response = self.api.resolve_handle(&handle_id).await?;
+            match response.status {
+                HandleResolutionStatus::Valid => {
+                    resolved_handle_ids.push(response.resolved_handle.id);
+                }
+                HandleResolutionStatus::Invalid => {
+                    bail!("Handle '{}' is not iMessage-capable.", handle_id);
+                }
+                HandleResolutionStatus::Unknown => {
+                    bail!("Handle '{}' could not be resolved.", handle_id);
+                }
+            }
+        }
+
+        Ok(resolved_handle_ids)
+    }
+
+    pub async fn reply(&mut self, conversation_id: String, message: String) -> Result<()> {
+        self.send_message(OutgoingMessageTarget::Conversation(conversation_id), message)
+            .await
+    }
+
+    pub async fn new_message(&mut self, handle_ids: Vec<String>, message: String) -> Result<()> {
+        let resolved_handle_ids = self.resolve_handle_ids(handle_ids).await?;
+        self.send_message(OutgoingMessageTarget::Handles(resolved_handle_ids), message)
+            .await
+    }
+
     pub async fn mark_conversation_as_read(&mut self, conversation_id: String) -> Result<()> {
         self.api.mark_conversation_as_read(&conversation_id).await?;
         println!("Conversation marked as read: {}", conversation_id);
         Ok(())
     }
+
+    pub async fn delete_conversation(&mut self, conversation_id: String) -> Result<()> {
+        self.api.delete_conversation(&conversation_id).await?;
+        println!("Conversation deleted: {}", conversation_id);
+        Ok(())
+    }
 }