mostro_client/cli/
get_dm.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
use std::collections::HashSet;

use anyhow::Result;
use mostro_core::message::{Message, Payload};
use nostr_sdk::prelude::*;

use crate::{
    db::{connect, Order},
    util::get_direct_messages,
};

pub async fn execute_get_dm(
    since: &i64,
    trade_keys: Keys,
    client: &Client,
    from_user: bool,
) -> Result<()> {
    let mut dm: Vec<(String, String, u64)> = Vec::new();
    let pool = connect().await?;
    let orders = Order::get_all(&pool).await.unwrap();
    let trade_keys_hex = trade_keys.secret_key().to_secret_hex();
    let order_trade_keys = orders
        .iter()
        .filter_map(|order| order.trade_keys.as_ref().cloned())
        .collect::<Vec<String>>();
    let mut unique_trade_keys = order_trade_keys
        .iter()
        .cloned()
        .collect::<HashSet<String>>();
    unique_trade_keys.insert(trade_keys_hex);
    let final_trade_keys = unique_trade_keys.iter().cloned().collect::<Vec<String>>();
    for keys in final_trade_keys.iter() {
        let trade_keys =
            Keys::parse(keys).map_err(|e| anyhow::anyhow!("Failed to parse trade keys: {}", e))?;
        let dm_temp = get_direct_messages(client, &trade_keys, *since, from_user).await;
        dm.extend(dm_temp);
    }

    if dm.is_empty() {
        println!();
        println!("No new messages");
        println!();
    } else {
        for el in dm.iter() {
            match Message::from_json(&el.0) {
                Ok(m) => {
                    if m.get_inner_message_kind().id.is_some() {
                        println!(
                            "Mostro sent you this message for order id: {} at {}",
                            m.get_inner_message_kind().id.unwrap(),
                            el.1
                        );
                    }
                    if let Some(Payload::PaymentRequest(_, inv, _)) =
                        &m.get_inner_message_kind().payload
                    {
                        println!();
                        println!("Pay this invoice to continue --> {}", inv);
                        println!();
                    } else if let Some(Payload::TextMessage(text)) =
                        &m.get_inner_message_kind().payload
                    {
                        println!();
                        println!("{text}");
                        println!();
                    } else {
                        println!();
                        println!("Action: {}", m.get_inner_message_kind().action);
                        println!("Payload: {:#?}", m.get_inner_message_kind().payload);
                        println!();
                    }
                }
                Err(_) => {
                    println!("You got this message:");
                    println!();
                    println!("{}", el.0);
                    println!();
                }
            }
        }
    }
    Ok(())
}