blazegram 0.4.2

Telegram bot framework: clean chats, zero garbage, declarative screens, pure Rust MTProto.
Documentation 
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

//! Telegram Stars API: transactions, refunds.

use grammers_client::tl;

use super::GrammersAdapter;
use crate::error::ApiError;
use crate::types::*;

impl GrammersAdapter {
    pub(crate) async fn impl_get_star_transactions(
        &self,
        offset: Option<&str>,
        limit: Option<i32>,
    ) -> Result<StarTransactions, ApiError> {
        let result = self
            .client
            .invoke(&tl::functions::payments::GetStarsTransactions {
                inbound: false,
                outbound: false,
                ascending: false,
                ton: false,
                subscription_id: None,
                peer: tl::types::InputPeerSelf {}.into(),
                offset: offset.unwrap_or("").to_string(),
                limit: limit.unwrap_or(100),
            })
            .await
            .map_err(Self::convert_error)?;

        let tl::enums::payments::StarsStatus::Status(status) = result;
        let tl::enums::StarsAmount::Amount(balance_amount) = status.balance else {
            return Ok(StarTransactions {
                balance: StarBalance {
                    amount: 0,
                    nanos: 0,
                },
                transactions: vec![],
                next_offset: None,
            });
        };

        let transactions = status
            .history
            .unwrap_or_default()
            .into_iter()
            .map(|tx| {
                let tl::enums::StarsTransaction::Transaction(t) = tx;
                let (amount, nanos) = match t.amount {
                    tl::enums::StarsAmount::Amount(a) => (a.amount, a.nanos),
                    _ => (0, 0),
                };
                let source = match t.peer {
                    tl::enums::StarsTransactionPeer::Peer(p) => match p.peer {
                        tl::enums::Peer::User(u) => {
                            StarTransactionPeer::User(UserId(u.user_id as u64))
                        }
                        _ => StarTransactionPeer::Unknown,
                    },
                    tl::enums::StarsTransactionPeer::AppStore => StarTransactionPeer::AppStore,
                    tl::enums::StarsTransactionPeer::PlayMarket => StarTransactionPeer::PlayMarket,
                    tl::enums::StarsTransactionPeer::Fragment => StarTransactionPeer::Fragment,
                    tl::enums::StarsTransactionPeer::PremiumBot => StarTransactionPeer::PremiumBot,
                    tl::enums::StarsTransactionPeer::Ads => StarTransactionPeer::Ads,
                    tl::enums::StarsTransactionPeer::Api => StarTransactionPeer::Api,
                    _ => StarTransactionPeer::Unknown,
                };
                StarTransaction {
                    id: t.id,
                    amount,
                    nanos,
                    date: t.date,
                    source,
                    title: t.title,
                    description: t.description,
                    is_refund: t.refund,
                }
            })
            .collect();

        Ok(StarTransactions {
            balance: StarBalance {
                amount: balance_amount.amount,
                nanos: balance_amount.nanos,
            },
            transactions,
            next_offset: status.next_offset,
        })
    }

    pub(crate) async fn impl_refund_star_payment(
        &self,
        user_id: UserId,
        charge_id: &str,
    ) -> Result<(), ApiError> {
        let user_peer = self.resolve(ChatId(user_id.0 as i64))?;
        let input_user: tl::enums::InputUser = tl::types::InputUser {
            user_id: user_peer.id.bare_id(),
            access_hash: user_peer.auth.hash(),
        }
        .into();
        self.client
            .invoke(&tl::functions::payments::RefundStarsCharge {
                user_id: input_user,
                charge_id: charge_id.to_string(),
            })
            .await
            .map_err(Self::convert_error)?;
        Ok(())
    }
}