conogram 0.2.19

An async wrapper for Telegram Bot API
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use std::{
    future::{Future, IntoFuture},
    pin::Pin,
};

use serde::Serialize;

use crate::{
    api::API, entities::message::Message, errors::ConogramError, impl_into_future,
    request::RequestT, utils::deserialize_utils::is_false,
};

#[derive(Debug, Clone, Serialize)]
pub struct SetGameScoreParams {
    pub user_id: i64,
    pub score: i64,
    #[serde(default, skip_serializing_if = "is_false")]
    pub force: bool,
    #[serde(default, skip_serializing_if = "is_false")]
    pub disable_edit_message: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chat_id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inline_message_id: Option<String>,
}

impl_into_future!(SetGameScoreRequest<'a>);

///Use this method to set the score of the specified user in a game message. On success, if the message is not an inline message, the [Message](https://core.telegram.org/bots/api/#message) is returned, otherwise *True* is returned. Returns an error, if the new score is not greater than the user's current score in the chat and *force* is *False*.
#[derive(Clone)]
pub struct SetGameScoreRequest<'a> {
    api: &'a API,
    params: SetGameScoreParams,
}

impl<'a> RequestT for SetGameScoreRequest<'a> {
    type ParamsType = SetGameScoreParams;
    type ReturnType = Option<Message>;
    fn get_name() -> &'static str {
        "setGameScore"
    }
    fn get_api_ref(&self) -> &API {
        self.api
    }
    fn get_params_ref(&self) -> &Self::ParamsType {
        &self.params
    }
    fn is_multipart() -> bool {
        false
    }
}
impl<'a> SetGameScoreRequest<'a> {
    pub fn new(api: &'a API, user_id: impl Into<i64>, score: impl Into<i64>) -> Self {
        Self {
            api,
            params: SetGameScoreParams {
                user_id: user_id.into(),
                score: score.into(),
                force: bool::default(),
                disable_edit_message: bool::default(),
                chat_id: Option::default(),
                message_id: Option::default(),
                inline_message_id: Option::default(),
            },
        }
    }

    ///User identifier
    #[must_use]
    pub fn user_id(mut self, user_id: impl Into<i64>) -> Self {
        self.params.user_id = user_id.into();
        self
    }

    ///New score, must be non-negative
    #[must_use]
    pub fn score(mut self, score: impl Into<i64>) -> Self {
        self.params.score = score.into();
        self
    }

    ///Pass *True* if the high score is allowed to decrease. This can be useful when fixing mistakes or banning cheaters
    #[must_use]
    pub fn force(mut self, force: impl Into<bool>) -> Self {
        self.params.force = force.into();
        self
    }

    ///Pass *True* if the game message should not be automatically edited to include the current scoreboard
    #[must_use]
    pub fn disable_edit_message(mut self, disable_edit_message: impl Into<bool>) -> Self {
        self.params.disable_edit_message = disable_edit_message.into();
        self
    }

    ///Required if *inline\_message\_id* is not specified. Unique identifier for the target chat
    #[must_use]
    pub fn chat_id(mut self, chat_id: impl Into<i64>) -> Self {
        self.params.chat_id = Some(chat_id.into());
        self
    }

    ///Required if *inline\_message\_id* is not specified. Identifier of the sent message
    #[must_use]
    pub fn message_id(mut self, message_id: impl Into<i64>) -> Self {
        self.params.message_id = Some(message_id.into());
        self
    }

    ///Required if *chat\_id* and *message\_id* are not specified. Identifier of the inline message
    #[must_use]
    pub fn inline_message_id(mut self, inline_message_id: impl Into<String>) -> Self {
        self.params.inline_message_id = Some(inline_message_id.into());
        self
    }
}

impl API {
    ///Use this method to set the score of the specified user in a game message. On success, if the message is not an inline message, the [Message](https://core.telegram.org/bots/api/#message) is returned, otherwise *True* is returned. Returns an error, if the new score is not greater than the user's current score in the chat and *force* is *False*.
    pub fn set_game_score(
        &self,
        user_id: impl Into<i64>,
        score: impl Into<i64>,
    ) -> SetGameScoreRequest {
        SetGameScoreRequest::new(self, user_id, score)
    }
}

// Divider: all content below this line will be preserved after code regen