refactor: Split big utils.rs file in a module for being more usable

src/cli/get_dm.rs

@@ -1,5 +1,6 @@
 use anyhow::Result;
 use mostro_core::prelude::Message;
+use nostr_sdk::prelude::*;
 
 use crate::{
     cli::Context,
@@ -26,7 +27,7 @@ pub async fn execute_get_dm(
         fetch_events_list(list_kind, None, None, None, ctx, Some(since)).await?;
 
     // Extract (Message, u64) tuples from Event::MessageTuple variants
-    let mut dm_events: Vec<(Message, u64)> = Vec::new();
+    let mut dm_events: Vec<(Message, u64, PublicKey)> = Vec::new();
     for event in all_fetched_events {
         if let Event::MessageTuple(tuple) = event {
             dm_events.push(*tuple);

src/cli/get_dm_user.rs

@@ -1,10 +1,12 @@
 use crate::cli::Context;
-use crate::{db::Order, util::get_direct_messages_from_trade_keys};
+use crate::db::Order;
+use crate::util::{fetch_events_list, Event, ListKind};
 use anyhow::Result;
 use comfy_table::modifiers::UTF8_ROUND_CORNERS;
 use comfy_table::presets::UTF8_FULL;
 use comfy_table::Table;
 use mostro_core::prelude::*;
+use nostr_sdk::prelude::*;
 
 pub async fn execute_get_dm_user(since: &i64, ctx: &Context) -> Result<()> {
     // Get all trade keys from orders
@@ -19,28 +21,41 @@ pub async fn execute_get_dm_user(since: &i64, ctx: &Context) -> Result<()> {
     trade_keys_hex.sort();
     trade_keys_hex.dedup();
 
+    // Check if the trade keys are empty
     if trade_keys_hex.is_empty() {
         println!("No trade keys found in orders");
         return Ok(());
     }
 
+    // Print the number of trade keys
     println!(
         "Searching for DMs in {} trade keys...",
         trade_keys_hex.len()
     );
 
-    let direct_messages = get_direct_messages_from_trade_keys(
-        &ctx.client,
-        trade_keys_hex,
-        *since,
-        &ctx.mostro_pubkey,
+    let direct_messages = fetch_events_list(
+        ListKind::DirectMessagesUser,
+        None,
+        None,
+        None,
+        ctx,
+        Some(since),
     )
     .await?;
 
+    // Extract (Message, u64) tuples from Event::MessageTuple variants
+    let mut dm_events: Vec<(Message, u64, PublicKey)> = Vec::new();
+    // Check if the direct messages are empty
     if direct_messages.is_empty() {
         println!("You don't have any direct messages in your trade keys");
         return Ok(());
     }
+    // Extract the direct messages
+    for event in direct_messages {
+        if let Event::MessageTuple(tuple) = event {
+            dm_events.push(*tuple);
+        }
+    }
 
     let mut table = Table::new();
     table
@@ -49,7 +64,7 @@ pub async fn execute_get_dm_user(since: &i64, ctx: &Context) -> Result<()> {
         .set_content_arrangement(comfy_table::ContentArrangement::Dynamic)
         .set_header(vec!["Time", "From", "Message"]);
 
-    for (message, created_at, sender_pubkey) in direct_messages.iter() {
+    for (message, created_at, sender_pubkey) in dm_events.iter() {
         let datetime = chrono::DateTime::from_timestamp(*created_at as i64, 0);
         let formatted_date = match datetime {
             Some(dt) => dt.format("%Y-%m-%d %H:%M:%S").to_string(),

src/cli/rate_user.rs

@@ -5,7 +5,11 @@ use uuid::Uuid;
 
 const RATING_BOUNDARIES: [u8; 5] = [1, 2, 3, 4, 5];
 
-use crate::{cli::Context, db::Order, util::send_dm};
+use crate::{
+    cli::Context,
+    db::Order,
+    util::{print_dm_events, send_dm, wait_for_dm},
+};
 
 // Get the user rate
 fn get_user_rate(rating: &u8) -> Result<Payload> {
@@ -44,16 +48,23 @@ pub async fn execute_rate_user(order_id: &Uuid, rating: &u8, ctx: &Context) -> R
     .as_json()
     .map_err(|_| anyhow::anyhow!("Failed to serialize message"))?;
 
-    send_dm(
+    let sent_message = send_dm(
         &ctx.client,
         Some(&ctx.identity_keys),
         &trade_keys,
         &ctx.mostro_pubkey,
         rate_message,
         None,
         false,
-    )
-    .await?;
+    );
+
+    // Wait for incoming DM
+    let recv_event = wait_for_dm(ctx, Some(&trade_keys), sent_message).await?;
+
+    // Parse the incoming DM
+    // use a fake request id
+    let fake_request_id = Uuid::new_v4().as_u128() as u64;
+    print_dm_events(recv_event, fake_request_id, ctx, Some(&trade_keys)).await?;
 
     Ok(())
 }

src/parser/dms.rs

@@ -165,9 +165,8 @@ pub async fn print_commands_results(message: &MessageKind, ctx: &Context) -> Res
                 Err(anyhow::anyhow!("No order id found in message"))
             }
         }
-        Action::Rate => {
-            println!("Sats released!");
-            println!("You can rate the counterpart now");
+        Action::RateReceived => {
+            println!("Rate received! Thank you!");
             Ok(())
         }
         Action::FiatSentOk => {
@@ -217,7 +216,7 @@ pub async fn print_commands_results(message: &MessageKind, ctx: &Context) -> Res
                 Ok(())
             }
         }
-        Action::HoldInvoicePaymentSettled => {
+        Action::HoldInvoicePaymentSettled | Action::Released => {
             println!("Hold invoice payment settled");
             Ok(())
         }
@@ -317,7 +316,10 @@ pub async fn parse_dm_events(
     direct_messages
 }
 
-pub async fn print_direct_messages(dm: &[(Message, u64)], pool: &SqlitePool) -> Result<()> {
+pub async fn print_direct_messages(
+    dm: &[(Message, u64, PublicKey)],
+    pool: &SqlitePool,
+) -> Result<()> {
     if dm.is_empty() {
         println!();
         println!("No new messages");