mostro_client/cli/
get_dm.rs

1use std::collections::HashSet;
2
3use anyhow::Result;
4use chrono::DateTime;
5use mostro_core::message::{Action, Message, Payload};
6use nostr_sdk::prelude::*;
7use uuid::Uuid;
8
9use crate::{
10    db::{connect, Order, User},
11    util::{get_direct_messages, send_message_sync},
12};
13
14pub async fn execute_get_dm(
15    since: &i64,
16    identity_keys: Keys,
17    trade_keys: Keys,
18    trade_index: i64,
19    mostro_key: PublicKey,
20    client: &Client,
21    from_user: bool,
22) -> Result<()> {
23    let mut dm: Vec<(Message, u64)> = Vec::new();
24    let pool = connect().await?;
25    let orders = Order::get_all(&pool).await.unwrap();
26    let trade_keys_hex = trade_keys.secret_key().to_secret_hex();
27    let order_trade_keys = orders
28        .iter()
29        .filter_map(|order| order.trade_keys.as_ref().cloned())
30        .collect::<Vec<String>>();
31    let mut unique_trade_keys = order_trade_keys
32        .iter()
33        .cloned()
34        .collect::<HashSet<String>>();
35    unique_trade_keys.insert(trade_keys_hex);
36    let final_trade_keys = unique_trade_keys.iter().cloned().collect::<Vec<String>>();
37    for keys in final_trade_keys.iter() {
38        let trade_keys =
39            Keys::parse(keys).map_err(|e| anyhow::anyhow!("Failed to parse trade keys: {}", e))?;
40        let dm_temp = get_direct_messages(client, &trade_keys, *since, from_user).await;
41        dm.extend(dm_temp);
42    }
43
44    if dm.is_empty() {
45        println!();
46        println!("No new messages");
47        println!();
48    } else {
49        for m in dm.iter() {
50            let message = m.0.get_inner_message_kind();
51            let date = DateTime::from_timestamp(m.1 as i64, 0).unwrap();
52            if message.id.is_some() {
53                println!(
54                    "Mostro sent you this message for order id: {} at {}",
55                    m.0.get_inner_message_kind().id.unwrap(),
56                    date
57                );
58            }
59            if let Some(payload) = &message.payload {
60                match payload {
61                    Payload::PaymentRequest(_, inv, _) => {
62                        println!();
63                        println!("Pay this invoice to continue --> {}", inv);
64                        println!();
65                    }
66                    Payload::TextMessage(text) => {
67                        println!();
68                        println!("{text}");
69                        println!();
70                    }
71                    Payload::CantDo(Some(cant_do_reason)) => {
72                        println!();
73                        println!("Error: {:?}", cant_do_reason);
74                        println!();
75                    }
76                    Payload::Order(new_order) if message.action == Action::NewOrder => {
77                        let db_order =
78                            Order::get_by_id(&pool, &new_order.id.unwrap().to_string()).await;
79                        if db_order.is_err() {
80                            let _ = Order::new(&pool, new_order.clone(), &trade_keys, None)
81                                .await
82                                .map_err(|e| {
83                                    anyhow::anyhow!("Failed to create DB order: {:?}", e)
84                                })?;
85                            // Update last trade index
86                            match User::get(&pool).await {
87                                Ok(mut user) => {
88                                    user.set_last_trade_index(trade_index);
89                                    if let Err(e) = user.save(&pool).await {
90                                        println!("Failed to update user: {}", e);
91                                    }
92                                }
93                                Err(e) => println!("Failed to get user: {}", e),
94                            }
95                            let request_id = Uuid::new_v4().as_u128() as u64;
96                            // Now we send a message to Mostro letting it know the trade key and
97                            // trade index for this new order
98                            let message = Message::new_order(
99                                Some(new_order.id.unwrap()),
100                                Some(request_id),
101                                Some(trade_index),
102                                Action::TradePubkey,
103                                None,
104                            );
105                            let _ = send_message_sync(
106                                client,
107                                Some(&identity_keys),
108                                &trade_keys,
109                                mostro_key,
110                                message,
111                                false,
112                                false,
113                            )
114                            .await?;
115                        }
116                        println!();
117                        println!("Order: {:#?}", new_order);
118                        println!();
119                    }
120                    _ => {
121                        println!();
122                        println!("Action: {}", message.action);
123                        println!("Payload: {:#?}", message.payload);
124                        println!();
125                    }
126                }
127            } else {
128                println!();
129                println!("Action: {}", message.action);
130                println!("Payload: {:#?}", message.payload);
131                println!();
132            }
133        }
134    }
135    Ok(())
136}
mostro_client/cli/get_dm.rs

mostro_client/cli/
get_dm.rs
