1extern crate futures;
2extern crate telegram_bot_fork;
3extern crate tokio;
4extern crate tokio_timer;
5
6use std::{
7 env,
8 ops::Add,
9 time::{Duration, Instant},
10};
11
12use futures::{future::lazy, Future, Stream};
13
14use tokio_timer::Delay;
15
16use telegram_bot_fork::*;
17
18fn test_message(api: Api, message: Message) {
19 let simple = api.send(message.text_reply("Simple message"));
20
21 let markdown = api.send(
22 message
23 .text_reply("`Markdown message`")
24 .parse_mode(ParseMode::Markdown),
25 );
26
27 let html = api.send(
28 message
29 .text_reply("<b>Bold HTML message</b>")
30 .parse_mode(ParseMode::Html),
31 );
32
33 tokio::executor::current_thread::spawn({
34 let future = simple.and_then(|_| markdown).and_then(|_| html);
35
36 future.map_err(|_| ()).map(|_| ())
37 })
38}
39
40fn test_preview(api: Api, message: Message) {
41 let preview = api.send(message.text_reply("Message with preview https://telegram.org"));
42
43 let no_preview = api.send(
44 message
45 .text_reply("Message without preview https://telegram.org")
46 .disable_preview(),
47 );
48
49 tokio::executor::current_thread::spawn({
50 let future = preview.and_then(|_| no_preview);
51
52 future.map_err(|_| ()).map(|_| ())
53 })
54}
55
56fn test_reply(api: Api, message: Message) {
57 let msg = api.send(message.text_reply("Reply to message"));
58 let chat = api.send(message.chat.text("Text to message chat"));
59
60 let private = api.send(message.from.text("Private text"));
61
62 tokio::executor::current_thread::spawn({
63 let future = msg.and_then(|_| chat).and_then(|_| private);
64
65 future.map_err(|_| ()).map(|_| ())
66 })
67}
68
69fn test_forward(api: Api, message: Message) {
70 api.spawn(message.forward(&message.chat));
71
72 api.spawn(message.forward(&message.from))
73}
74
75fn test_edit_message(api: Api, message: Message) {
76 let round_1 = api.send(message.text_reply("Round 1"));
77
78 let duration_1 = Duration::from_secs(2);
79
80 let sleep_1 = Delay::new(Instant::now().add(duration_1)).from_err();
81
82 let round_2_api = api.clone();
83 let round_2 = round_1
84 .join(sleep_1)
85 .and_then(move |(message, _)| round_2_api.send(message.edit_text("Round 2")));
86
87 let duration_2 = Duration::from_secs(4);
88 let sleep_2 = Delay::new(Instant::now().add(duration_2)).from_err();
89
90 let round_3 = round_2
91 .join(sleep_2)
92 .map_err(|_| ())
93 .and_then(move |(message, _)| {
94 api.spawn(message.edit_text("Round 3"));
95 Ok(())
96 });
97
98 tokio::executor::current_thread::spawn(round_3)
99}
100
101fn test_get_chat(api: Api, message: Message) {
102 let chat = api.send(message.chat.get_chat());
103 let future = chat.and_then(move |chat| api.send(chat.text(format!("Chat id {}", chat.id()))));
104
105 tokio::executor::current_thread::spawn({ future.map_err(|_| ()).map(|_| ()) })
106}
107
108fn test_get_chat_administrators(api: Api, message: Message) {
109 let administrators = api.send(message.chat.get_administrators());
110 let future = administrators.and_then(move |administrators| {
111 let mut response = Vec::new();
112 for member in administrators {
113 response.push(member.user.first_name.clone())
114 }
115 api.send(message.text_reply(format!("Administrators: {}", response.join(", "))))
116 });
117
118 tokio::executor::current_thread::spawn({ future.map_err(|_| ()).map(|_| ()) })
119}
120
121fn test_get_chat_members_count(api: Api, message: Message) {
122 let count = api.send(message.chat.get_members_count());
123 let future = count
124 .and_then(move |count| api.send(message.text_reply(format!("Members count: {}", count))));
125
126 tokio::executor::current_thread::spawn({ future.map_err(|_| ()).map(|_| ()) })
127}
128
129fn test_get_chat_member(api: Api, message: Message) {
130 let member = api.send(message.chat.get_member(&message.from));
131 let future = member.and_then(move |member| {
132 let first_name = member.user.first_name.clone();
133 let status = member.status;
134 api.send(message.text_reply(format!("Member {}, status {:?}", first_name, status)))
135 });
136
137 tokio::executor::current_thread::spawn({ future.map_err(|_| ()).map(|_| ()) })
138}
139
140fn test_get_user_profile_photos(api: Api, message: Message) {
141 let photos = api.send(message.from.get_user_profile_photos());
142
143 let future = photos.and_then(move |photos| {
144 api.send(message.text_reply(format!("Found photos: {}", photos.total_count)))
145 });
146
147 tokio::executor::current_thread::spawn({ future.map_err(|_| ()).map(|_| ()) })
148}
149
150fn test_leave(api: Api, message: Message) {
151 api.spawn(message.chat.leave())
152}
153
154fn test(api: Api, message: Message) {
155 let function: fn(Api, Message) = match message.kind {
156 MessageKind::Text { ref data, .. } => match data.as_str() {
157 "/message" => test_message,
158 "/preview" => test_preview,
159 "/reply" => test_reply,
160 "/forward" => test_forward,
161 "/edit-message" => test_edit_message,
162 "/get_chat" => test_get_chat,
163 "/get_chat_administrators" => test_get_chat_administrators,
164 "/get_chat_members_count" => test_get_chat_members_count,
165 "/get_chat_member" => test_get_chat_member,
166 "/get_user_profile_photos" => test_get_user_profile_photos,
167 "/leave" => test_leave,
168 _ => return,
169 },
170 _ => return,
171 };
172
173 function(api, message)
174}
175
176fn main() {
177 tokio::runtime::current_thread::Runtime::new()
178 .unwrap()
179 .block_on(lazy(|| {
180 let token = env::var("TELEGRAM_BOT_TOKEN").unwrap();
181 let api = Api::new(token).unwrap();
182
183 let stream = api.stream().then(|mb_update| {
184 let res: Result<Result<Update, Error>, ()> = Ok(mb_update);
185 res
186 });
187
188 stream.for_each(move |update| {
189 match update {
190 Ok(update) => {
191 if let UpdateKind::Message(message) = update.kind {
192 test(api.clone(), message)
193 }
194 }
195 Err(_) => {}
196 }
197
198 Ok(())
199 })
200 }))
201 .unwrap();
202}