teloxide_tests 0.4.0

Test suite for teloxide bots
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

use std::sync::Mutex;

use actix_web::{error::ErrorBadRequest, web, Responder};
use chrono::DateTime;
use serde::Deserialize;
use teloxide::types::{
    BusinessConnectionId, EffectId, InputPollOption, Me, MessageEntity, ParseMode, PollOption,
    PollType, ReplyMarkup, ReplyParameters, Seconds,
};

use super::{make_telegram_result, BodyChatId};
use crate::{
    server::{routes::check_if_message_exists, SentMessagePoll},
    state::State,
    MockMessagePoll,
};

#[derive(Debug, Deserialize, Clone)]
pub struct SendMessagePollBody {
    pub chat_id: BodyChatId,
    pub message_thread_id: Option<i64>,
    pub question: String,
    pub question_parse_mode: Option<ParseMode>,
    pub question_entities: Option<Vec<MessageEntity>>,
    pub options: Vec<InputPollOption>,
    pub is_anonymous: Option<bool>,
    pub r#type: Option<PollType>,
    pub allows_multiple_answers: Option<bool>,
    pub correct_option_id: Option<u8>,
    pub explanation: Option<String>,
    pub explanation_parse_mode: Option<ParseMode>,
    pub explanation_entities: Option<Vec<MessageEntity>>,
    pub open_period: Option<Seconds>,
    pub close_date: Option<u16>,
    pub is_closed: Option<bool>,
    pub disable_notification: Option<bool>,
    pub protect_content: Option<bool>,
    pub message_effect_id: Option<EffectId>,
    pub reply_markup: Option<ReplyMarkup>,
    pub reply_parameters: Option<ReplyParameters>,
    pub business_connection_id: Option<BusinessConnectionId>,
}

pub async fn send_poll(
    state: web::Data<Mutex<State>>,
    body: web::Json<SendMessagePollBody>,
    me: web::Data<Me>,
) -> impl Responder {
    let mut lock = state.lock().unwrap();
    let chat = body.chat_id.chat();
    let mut message = // Creates the message, which will be mutated to fit the needed shape
        MockMessagePoll::new().chat(chat);
    message.from = Some(me.user.clone());
    message.has_protected_content = body.protect_content.unwrap_or(false);
    message.business_connection_id = body.business_connection_id.clone();

    message.question = body.question.clone();
    let mut options = vec![];
    for option in body.options.iter() {
        options.push(PollOption {
            text: option.text.clone(),
            text_entities: None,
            voter_count: 0,
        });
    }
    message.options = options;
    message.is_anonymous = body.is_anonymous.unwrap_or(false);
    message.poll_type = body.r#type.clone().unwrap_or(PollType::Regular);
    message.allows_multiple_answers = body.allows_multiple_answers.unwrap_or(false);
    message.correct_option_id = body.correct_option_id;
    message.explanation = body.explanation.clone();
    message.explanation_entities = body.explanation_entities.clone();
    message.open_period = body.open_period;
    message.close_date = DateTime::from_timestamp(body.close_date.unwrap_or(0) as i64, 0);
    message.effect_id = body.message_effect_id.clone();
    message.question_entities = body.question_entities.clone();

    if let Some(reply_parameters) = &body.reply_parameters {
        check_if_message_exists!(lock, reply_parameters.message_id.0);
        let reply_to_message = lock
            .messages
            .get_message(reply_parameters.message_id.0)
            .unwrap();
        message.reply_to_message = Some(Box::new(reply_to_message.clone()));
    }
    if let Some(ReplyMarkup::InlineKeyboard(markup)) = body.reply_markup.clone() {
        message.reply_markup = Some(markup);
    }

    let last_id = lock.messages.max_message_id();
    let message = lock.messages.add_message(message.id(last_id + 1).build());

    lock.responses.sent_messages.push(message.clone());
    lock.responses.sent_messages_poll.push(SentMessagePoll {
        message: message.clone(),
        bot_request: body.into_inner(),
    });

    make_telegram_result(message)
}