feat: add rabbit fixes and improved other parts

Author: arkanoider

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

@@ -316,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");

src/util/events.rs

@@ -10,40 +10,6 @@ const FAKE_SINCE: i64 = 2880;
 
 use super::types::{Event, ListKind};
 
-pub async fn get_direct_messages_from_trade_keys(
-    client: &Client,
-    trade_keys_hex: Vec<String>,
-    since: i64,
-    _mostro_pubkey: &PublicKey,
-) -> Result<Vec<(Message, u64, PublicKey)>> {
-    if trade_keys_hex.is_empty() {
-        return Ok(Vec::new());
-    }
-
-    let since_time = chrono::Utc::now()
-        .checked_sub_signed(chrono::Duration::minutes(since))
-        .ok_or(anyhow::anyhow!("Failed to get since time"))?
-        .timestamp();
-
-    let mut all_messages: Vec<(Message, u64, PublicKey)> = Vec::new();
-    for trade_key_hex in trade_keys_hex {
-        if let Ok(public_key) = PublicKey::from_hex(&trade_key_hex) {
-            let filter =
-                create_filter(ListKind::DirectMessagesUser, public_key, Some(&since_time))?;
-            let events = client.fetch_events(filter, FETCH_EVENTS_TIMEOUT).await?;
-            for event in events {
-                if let Ok(message) = Message::from_json(&event.content) {
-                    if event.created_at.as_u64() < since as u64 {
-                        continue;
-                    }
-                    all_messages.push((message, event.created_at.as_u64(), event.pubkey));
-                }
-            }
-        }
-    }
-    Ok(all_messages)
-}
-
 fn create_fake_timestamp() -> Result<Timestamp> {
     let fake_since_time = chrono::Utc::now()
         .checked_sub_signed(chrono::Duration::minutes(FAKE_SINCE))
@@ -130,11 +96,13 @@ pub async fn fetch_events_list(
                 parse_dm_events(fetched_events, &ctx.context_keys, since).await;
             Ok(direct_messages_mostro
                 .into_iter()
-                .map(|(message, timestamp, _)| Event::MessageTuple(Box::new((message, timestamp))))
+                .map(|(message, timestamp, sender_pubkey)| {
+                    Event::MessageTuple(Box::new((message, timestamp, sender_pubkey)))
+                })
                 .collect())
         }
         ListKind::PrivateDirectMessagesUser => {
-            let mut direct_messages: Vec<(Message, u64)> = Vec::new();
+            let mut direct_messages: Vec<(Message, u64, PublicKey)> = Vec::new();
             for index in 1..=ctx.trade_index {
                 let trade_key = User::get_trade_keys(&ctx.pool, index).await?;
                 let filter = create_filter(
@@ -148,19 +116,16 @@ pub async fn fetch_events_list(
                     .await?;
                 let direct_messages_for_trade_key =
                     parse_dm_events(fetched_user_messages, &trade_key, since).await;
-                direct_messages.extend(
-                    direct_messages_for_trade_key
-                        .into_iter()
-                        .map(|(message, timestamp, _)| (message, timestamp)),
-                );
+                // Extend the direct messages
+                direct_messages.extend(direct_messages_for_trade_key);
             }
             Ok(direct_messages
                 .into_iter()
                 .map(|t| Event::MessageTuple(Box::new(t)))
                 .collect())
         }
         ListKind::DirectMessagesUser => {
-            let mut direct_messages: Vec<(Message, u64)> = Vec::new();
+            let mut direct_messages: Vec<(Message, u64, PublicKey)> = Vec::new();
             for index in 1..=ctx.trade_index {
                 let trade_key = User::get_trade_keys(&ctx.pool, index).await?;
                 let filter =
@@ -171,11 +136,8 @@ pub async fn fetch_events_list(
                     .await?;
                 let direct_messages_for_trade_key =
                     parse_dm_events(fetched_user_messages, &trade_key, since).await;
-                direct_messages.extend(
-                    direct_messages_for_trade_key
-                        .into_iter()
-                        .map(|(message, timestamp, _)| (message, timestamp)),
-                );
+                // Extend the direct messages
+                direct_messages.extend(direct_messages_for_trade_key);
             }
             Ok(direct_messages
                 .into_iter()

src/util/messaging.rs

@@ -245,14 +245,21 @@ pub async fn print_dm_events(
     let messages = parse_dm_events(recv_event, trade_keys, None).await;
     if let Some((message, _, _)) = messages.first() {
         let message = message.get_inner_message_kind();
-        if message.request_id == Some(request_id) {
-            print_commands_results(message, ctx).await?;
-        } else {
-            return Err(anyhow::anyhow!(
-                "Received response with mismatched request_id. Expected: {}, Got: {:?}",
-                request_id,
-                message.request_id
-            ));
+        match message.request_id {
+            Some(id) => {
+                if request_id == id {
+                    print_commands_results(message, ctx).await?;
+                }
+            }
+            None if message.action == Action::RateReceived => {
+                print_commands_results(message, ctx).await?;
+            }
+            None => {
+                return Err(anyhow::anyhow!(
+                    "Received response with mismatched request_id. Expected: {}, Got: Null",
+                    request_id,
+                ));
+            }
         }
     } else {
         return Err(anyhow::anyhow!("No response received from Mostro"));

src/util/misc.rs

@@ -10,7 +10,7 @@ pub fn uppercase_first(s: &str) -> String {
 
 pub fn get_mcli_path() -> String {
     let home_dir = dirs::home_dir().expect("Couldn't get home directory");
-    let mcli_path = format!("{}/.mcli", home_dir.display());
+    let mcli_path = format!("{}/.mcliUserA", home_dir.display());
     if !Path::new(&mcli_path).exists() {
         fs::create_dir(&mcli_path).expect("Couldn't create mostro-cli directory in HOME");
         println!("Directory {} created.", mcli_path);

src/util/mod.rs

@@ -6,9 +6,7 @@ pub mod storage;
 pub mod types;
 
 // Re-export commonly used items to preserve existing import paths
-pub use events::{
-    create_filter, fetch_events_list, get_direct_messages_from_trade_keys, FETCH_EVENTS_TIMEOUT,
-};
+pub use events::{create_filter, fetch_events_list, FETCH_EVENTS_TIMEOUT};
 pub use messaging::{
     print_dm_events, send_admin_gift_wrap_dm, send_dm, send_gift_wrap_dm, wait_for_dm,
 };

src/util/types.rs

@@ -1,10 +1,11 @@
 use mostro_core::prelude::*;
+use nostr_sdk::prelude::*;
 
 #[derive(Clone, Debug)]
 pub enum Event {
     SmallOrder(SmallOrder),
     Dispute(Dispute),
-    MessageTuple(Box<(Message, u64)>),
+    MessageTuple(Box<(Message, u64, PublicKey)>),
 }
 
 #[derive(Clone, Debug)]

tests/parser_dms.rs

@@ -13,7 +13,7 @@ async fn parse_dm_empty() {
 #[tokio::test]
 async fn print_dms_empty() {
     let pool = sqlx::SqlitePool::connect("sqlite::memory:").await.unwrap();
-    let msgs: Vec<(Message, u64)> = Vec::new();
+    let msgs: Vec<(Message, u64, PublicKey)> = Vec::new();
     let res = print_direct_messages(&msgs, &pool).await;
     assert!(res.is_ok());
 }