refactor: completing new commands refactor, neworder and take order works now

Author: arkanoider

src/cli.rs

@@ -177,9 +177,6 @@ pub enum Commands {
         #[arg(short, long)]
         #[clap(default_value_t = 30)]
         since: i64,
-        /// If true, get messages from counterparty, otherwise from Mostro
-        #[arg(short)]
-        from_user: bool,
     },
     /// Get direct messages sent to any trade keys
     GetDmUser {
@@ -194,9 +191,6 @@ pub enum Commands {
         #[arg(short, long)]
         #[clap(default_value_t = 30)]
         since: i64,
-        /// If true, get messages from counterparty, otherwise from Mostro
-        #[arg(short)]
-        from_user: bool,
     },
     /// Send direct message to a user
     SendDm {
@@ -543,6 +537,7 @@ impl Commands {
                     &ctx.identity_keys,
                     ctx.mostro_pubkey,
                     &ctx.client,
+                    &ctx.pool,
                 )
                 .await
             }
@@ -558,32 +553,14 @@ impl Commands {
             }
 
             // DM retrieval commands
-            Commands::GetDm { since, from_user } => {
-                execute_get_dm(
-                    since,
-                    ctx.trade_index,
-                    &ctx.mostro_keys,
-                    &ctx.client,
-                    *from_user,
-                    false,
-                    &ctx.mostro_pubkey,
-                )
-                .await
+            Commands::GetDm { since } => {
+                execute_get_dm(since, ctx.trade_index, &ctx.mostro_keys, &ctx.client, false).await
             }
             Commands::GetDmUser { since } => {
-                execute_get_dm_user(since, &ctx.client, &ctx.mostro_pubkey).await
+                execute_get_dm_user(since, &ctx.client, &ctx.mostro_pubkey, &ctx.pool).await
             }
-            Commands::GetAdminDm { since, from_user } => {
-                execute_get_dm(
-                    since,
-                    ctx.trade_index,
-                    &ctx.mostro_keys,
-                    &ctx.client,
-                    *from_user,
-                    true,
-                    &ctx.mostro_pubkey,
-                )
-                .await
+            Commands::GetAdminDm { since } => {
+                execute_get_dm(since, ctx.trade_index, &ctx.mostro_keys, &ctx.client, true).await
             }
 
             // Admin commands

src/cli/add_invoice.rs

@@ -1,10 +1,10 @@
-use crate::db::connect;
 use crate::util::{send_dm, wait_for_dm};
 use crate::{db::Order, lightning::is_valid_invoice};
 use anyhow::Result;
 use lnurl::lightning_address::LightningAddress;
 use mostro_core::prelude::*;
 use nostr_sdk::prelude::*;
+use sqlx::SqlitePool;
 use std::str::FromStr;
 use uuid::Uuid;
 
@@ -14,9 +14,9 @@ pub async fn execute_add_invoice(
     identity_keys: &Keys,
     mostro_key: PublicKey,
     client: &Client,
+    pool: &SqlitePool,
 ) -> Result<()> {
-    let pool = connect().await?;
-    let order = Order::get_by_id(&pool, &order_id.to_string()).await?;
+    let order = Order::get_by_id(pool, &order_id.to_string()).await?;
     let trade_keys = order
         .trade_keys
         .clone()
@@ -40,6 +40,8 @@ pub async fn execute_add_invoice(
             }
         }
     };
+
+    // Create request id
     let request_id = Uuid::new_v4().as_u128() as u64;
     // Create AddInvoice message
     let add_invoice_message = Message::new_order(
@@ -50,35 +52,24 @@ pub async fn execute_add_invoice(
         payload,
     );
 
+    // Serialize the message
     let message_json = add_invoice_message
         .as_json()
         .map_err(|_| anyhow::anyhow!("Failed to serialize message"))?;
 
-    // Clone the keys and client for the async call
-    let identity_keys = identity_keys.clone();
-    let trade_keys_clone = trade_keys.clone();
-    let client_clone = client.clone();
-
-    // Spawn a new task to send the DM
-    // This is so we can wait for the gift wrap event in the main thread
-    tokio::spawn(async move {
-        if let Err(e) = send_dm(
-            &client_clone,
-            Some(&identity_keys.clone()),
-            &trade_keys_clone,
-            &mostro_key,
-            message_json,
-            None,
-            false,
-        )
-        .await
-        {
-            eprintln!("Failed to send DM: {}", e);
-        }
-    });
-
-    // Wait for the DM to be sent from mostro
-    wait_for_dm(client, &trade_keys, request_id, 0, Some(order)).await?;
+    // Send DM
+    send_dm(
+        client,
+        Some(identity_keys),
+        &trade_keys,
+        &mostro_key,
+        message_json,
+        None,
+        false,
+    )
+    .await?;
 
+    // Wait for the DM to be sent from mostro and update the order
+    wait_for_dm(client, &trade_keys, request_id, None, Some(order)).await?;
     Ok(())
 }

src/cli/adm_send_dm.rs

@@ -14,11 +14,14 @@ pub async fn execute_adm_send_dm(
         }
     };
 
-    println!("SENDING DM with admin keys: {}", admin_keys.public_key().to_hex());
+    println!(
+        "SENDING DM with admin keys: {}",
+        admin_keys.public_key().to_hex()
+    );
 
     send_admin_gift_wrap_dm(client, &admin_keys, &receiver, message).await?;
 
     println!("Admin gift wrap message sent to {}", receiver);
 
     Ok(())
-}
+}

src/cli/dm_to_user.rs

@@ -19,9 +19,12 @@ pub async fn execute_dm_to_user(
         None => anyhow::bail!("No trade_keys found for this order"),
     };
 
-    println!("SENDING DM with trade keys: {}", trade_keys.public_key().to_hex());
+    println!(
+        "SENDING DM with trade keys: {}",
+        trade_keys.public_key().to_hex()
+    );
 
     send_gift_wrap_dm(client, &trade_keys, &receiver, message).await?;
 
     Ok(())
-}
+}

src/cli/get_dm.rs

@@ -1,11 +1,10 @@
 use anyhow::Result;
-use chrono::DateTime;
 use mostro_core::prelude::*;
 use nostr_sdk::prelude::*;
 
 use crate::{
-    db::{connect, Order, User},
-    parser::dms::parse_dm_events,
+    db::{connect, User},
+    parser::dms::{parse_dm_events, print_direct_messages},
     util::{create_filter, ListKind},
 };
 
@@ -14,11 +13,9 @@ pub async fn execute_get_dm(
     trade_index: i64,
     mostro_keys: &Keys,
     client: &Client,
-    _from_user: bool,
     admin: bool,
-    _mostro_pubkey: &PublicKey,
 ) -> Result<()> {
-    let mut dm: Vec<(Message, u64)> = Vec::new();
+    let mut dm: Vec<(Message, u64, PublicKey)> = Vec::new();
     let pool = connect().await?;
     if !admin {
         for index in 1..=trade_index {
@@ -39,79 +36,6 @@ pub async fn execute_get_dm(
         dm.extend(dm_temp);
     }
 
-    if dm.is_empty() {
-        println!();
-        println!("No new messages");
-        println!();
-    } else {
-        for m in dm.iter() {
-            let message = m.0.get_inner_message_kind();
-            let date = DateTime::from_timestamp(m.1 as i64, 0).unwrap();
-            if message.id.is_some() {
-                println!(
-                    "Mostro sent you this message for order id: {} at {}",
-                    m.0.get_inner_message_kind().id.unwrap(),
-                    date
-                );
-            }
-            if let Some(payload) = &message.payload {
-                match payload {
-                    Payload::PaymentRequest(_, inv, _) => {
-                        println!();
-                        println!("Pay this invoice to continue --> {}", inv);
-                        println!();
-                    }
-                    Payload::TextMessage(text) => {
-                        println!();
-                        println!("{text}");
-                        println!();
-                    }
-                    Payload::Dispute(id, info) => {
-                        println!("Action: {}", message.action);
-                        println!("Dispute id: {}", id);
-                        if let Some(info) = info {
-                            println!();
-                            println!("Dispute info: {:#?}", info);
-                            println!();
-                        }
-                    }
-                    Payload::CantDo(Some(cant_do_reason)) => {
-                        println!();
-                        println!("Error: {:?}", cant_do_reason);
-                        println!();
-                    }
-                    Payload::Order(new_order) if message.action == Action::NewOrder => {
-                        if new_order.id.is_some() {
-                            let db_order =
-                                Order::get_by_id(&pool, &new_order.id.unwrap().to_string()).await;
-                            if db_order.is_err() {
-                                let trade_index = message.trade_index.unwrap();
-                                let trade_keys = User::get_trade_keys(&pool, trade_index).await?;
-                                let _ = Order::new(&pool, new_order.clone(), &trade_keys, None)
-                                    .await
-                                    .map_err(|e| {
-                                        anyhow::anyhow!("Failed to create DB order: {:?}", e)
-                                    })?;
-                            }
-                        }
-                        println!();
-                        println!("Order: {:#?}", new_order);
-                        println!();
-                    }
-                    _ => {
-                        println!();
-                        println!("Action: {}", message.action);
-                        println!("Payload: {:#?}", message.payload);
-                        println!();
-                    }
-                }
-            } else {
-                println!();
-                println!("Action: {}", message.action);
-                println!("Payload: {:#?}", message.payload);
-                println!();
-            }
-        }
-    }
+    print_direct_messages(&dm, &pool).await?;
     Ok(())
 }

src/cli/get_dm_user.rs

@@ -5,16 +5,16 @@ use comfy_table::presets::UTF8_FULL;
 use comfy_table::Table;
 use mostro_core::prelude::*;
 use nostr_sdk::prelude::*;
+use sqlx::SqlitePool;
 
 pub async fn execute_get_dm_user(
     since: &i64,
     client: &Client,
     mostro_pubkey: &PublicKey,
+    pool: &SqlitePool,
 ) -> Result<()> {
-    let pool = crate::db::connect().await?;
-
     // Get all trade keys from orders
-    let mut trade_keys_hex = Order::get_all_trade_keys(&pool).await?;
+    let mut trade_keys_hex = Order::get_all_trade_keys(pool).await?;
 
     // Add admin private key to search for messages sent TO admin
     if let Ok(admin_privkey_hex) = std::env::var("NSEC_PRIVKEY") {

src/cli/new_order.rs

@@ -161,7 +161,7 @@ pub async fn execute_new_order(
     });
 
     // Wait for the DM to be sent from mostro
-    wait_for_dm(client, trade_keys, request_id, trade_index, None).await?;
+    wait_for_dm(client, trade_keys, request_id, Some(trade_index), None).await?;
 
     Ok(())
 }

src/cli/send_msg.rs

@@ -111,7 +111,7 @@ pub async fn execute_send_msg(
             });
 
             // Wait for the DM to be sent from mostro
-            wait_for_dm(client, &trade_keys, request_id, 0, Some(order)).await?;
+            wait_for_dm(client, &trade_keys, request_id, None, Some(order)).await?;
         }
     }
 

src/cli/take_buy.rs

@@ -70,7 +70,7 @@ pub async fn execute_take_buy(
     });
 
     // Wait for the DM to be sent from mostro
-    wait_for_dm(client, trade_keys, request_id, trade_index, None).await?;
+    wait_for_dm(client, trade_keys, request_id, Some(trade_index), None).await?;
 
     Ok(())
 }

src/cli/take_sell.rs

@@ -112,7 +112,7 @@ pub async fn execute_take_sell(
     client.subscribe(subscription, None).await?;
 
     // Wait for the DM to be sent from mostro
-    wait_for_dm(client, trade_keys, request_id, trade_index, None).await?;
+    wait_for_dm(client, trade_keys, request_id, Some(trade_index), None).await?;
 
     Ok(())
 }