mostro_client/cli/
get_dm.rs

1use anyhow::Result;
2use chrono::DateTime;
3use mostro_core::prelude::*;
4use nostr_sdk::prelude::*;
5
6use crate::{
7    db::{connect, Order, User},
8    util::get_direct_messages,
9};
10
11pub async fn execute_get_dm(
12    since: &i64,
13    trade_index: i64,
14    client: &Client,
15    from_user: bool,
16    admin: bool,
17    mostro_pubkey: &PublicKey,
18) -> Result<()> {
19    let mut dm: Vec<(Message, u64)> = Vec::new();
20    let pool = connect().await?;
21    if !admin {
22        for index in 1..=trade_index {
23            let keys = User::get_trade_keys(&pool, index).await?;
24            let dm_temp =
25                get_direct_messages(client, &keys, *since, from_user, Some(mostro_pubkey)).await;
26            dm.extend(dm_temp);
27        }
28    } else {
29        let id_key = match std::env::var("NSEC_PRIVKEY") {
30            Ok(id_key) => Keys::parse(&id_key)?,
31            Err(e) => {
32                println!("Failed to get mostro admin private key: {}", e);
33                std::process::exit(1);
34            }
35        };
36        let dm_temp =
37            get_direct_messages(client, &id_key, *since, from_user, Some(mostro_pubkey)).await;
38        dm.extend(dm_temp);
39    }
40
41    if dm.is_empty() {
42        println!();
43        println!("No new messages");
44        println!();
45    } else {
46        for m in dm.iter() {
47            let message = m.0.get_inner_message_kind();
48            let date = DateTime::from_timestamp(m.1 as i64, 0).unwrap();
49            if message.id.is_some() {
50                println!(
51                    "Mostro sent you this message for order id: {} at {}",
52                    m.0.get_inner_message_kind().id.unwrap(),
53                    date
54                );
55            }
56            if let Some(payload) = &message.payload {
57                match payload {
58                    Payload::PaymentRequest(_, inv, _) => {
59                        println!();
60                        println!("Pay this invoice to continue --> {}", inv);
61                        println!();
62                    }
63                    Payload::TextMessage(text) => {
64                        println!();
65                        println!("{text}");
66                        println!();
67                    }
68                    Payload::Dispute(id, info) => {
69                        println!("Action: {}", message.action);
70                        println!("Dispute id: {}", id);
71                        if let Some(info) = info {
72                            println!();
73                            println!("Dispute info: {:#?}", info);
74                            println!();
75                        }
76                    }
77                    Payload::CantDo(Some(cant_do_reason)) => {
78                        println!();
79                        println!("Error: {:?}", cant_do_reason);
80                        println!();
81                    }
82                    Payload::Order(new_order) if message.action == Action::NewOrder => {
83                        if new_order.id.is_some() {
84                            let db_order =
85                                Order::get_by_id(&pool, &new_order.id.unwrap().to_string()).await;
86                            if db_order.is_err() {
87                                let trade_index = message.trade_index.unwrap();
88                                let trade_keys = User::get_trade_keys(&pool, trade_index).await?;
89                                let _ = Order::new(&pool, new_order.clone(), &trade_keys, None)
90                                    .await
91                                    .map_err(|e| {
92                                        anyhow::anyhow!("Failed to create DB order: {:?}", e)
93                                    })?;
94                            }
95                        }
96                        println!();
97                        println!("Order: {:#?}", new_order);
98                        println!();
99                    }
100                    _ => {
101                        println!();
102                        println!("Action: {}", message.action);
103                        println!("Payload: {:#?}", message.payload);
104                        println!();
105                    }
106                }
107            } else {
108                println!();
109                println!("Action: {}", message.action);
110                println!("Payload: {:#?}", message.payload);
111                println!();
112            }
113        }
114    }
115    Ok(())
116}