OpenSource/teloxide
OpenSource/teloxide
1
0
Fork 0
mirror of https://github.com/teloxide/teloxide.git synced 2025-01-10 20:12:25 +01:00
Code Issues Projects Releases Packages Wiki Activity

Merge remote-tracking branch 'origin/dev' into dev

Browse source 
# Conflicts:
#	src/dispatching/dispatchers/filter/mod.rs
This commit is contained in:
P0lunin 2019-10-21 13:32:38 +03:00
commit 65320feaf0
29 changed files with 440 additions and 182 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

BIN
hw.doc Normal file
View file

Binary file not shown.

58
src/bot/api.rs
View file

@ -2,20 +2,20 @@ use crate::{
bot::Bot,
requests::{
AnswerCallbackQuery, AnswerPreCheckoutQuery, AnswerShippingQuery,
DeleteChatStickerSet, EditMessageLiveLocation, ForwardMessage,
DeleteChatPhoto, DeleteChatStickerSet, EditMessageLiveLocation,
ExportCharInviteLink, ForwardMessage, GetChat, GetChatAdministrators,
GetChatMember, GetChatMembersCount, GetFile, GetMe, GetUpdates,
KickChatMember, PinChatMessage, PromoteChatMember, RestrictChatMember,
SendAnimation, SendAudio, SendChatAction, SendContact, SendDocument,
SendLocation, SendMediaGroup, SendMessage, SendPhoto, SendPoll,
SendVenue, SendVideo, SendVideoNote, SendVoice, SetChatDescription,
SetChatStickerSet, StopMessageLiveLocation, UnbanChatMember,
UnpinChatMessage, SetChatTitle, DeleteChatPhoto, SetChatPhoto,
ExportCharInviteLink, SetChatPermissions
KickChatMember, LeaveChat, PinChatMessage, PromoteChatMember,
RestrictChatMember, SendAnimation, SendAudio, SendChatAction,
SendContact, SendDocument, SendLocation, SendMediaGroup, SendMessage,
SendPhoto, SendPoll, SendVenue, SendVideo, SendVideoNote, SendVoice,
SetChatDescription, SetChatPermissions, SetChatPhoto,
SetChatStickerSet, SetChatTitle, StopMessageLiveLocation,
UnbanChatMember, UnpinChatMessage,
},
types::{ChatAction, ChatId, ChatPermissions, InputFile, InputMedia},
};
/// Telegram functions
impl Bot {
pub fn get_me(&self) -> GetMe {
GetMe::new(self)
@ -120,6 +120,13 @@ impl Bot {
AnswerPreCheckoutQuery::new(self, pre_checkout_query_id, ok)
}
pub fn get_chat<I>(&self, chat_id: I) -> GetChat
where
I: Into<ChatId>,
{
GetChat::new(self, chat_id)
}
pub fn answer_shipping_query<I, O>(
&self,
shipping_query_id: I,
@ -323,6 +330,16 @@ impl Bot {
GetChatMember::new(self, chat_id, user_id)
}
pub fn get_chat_administrators<C, I>(
&self,
chat_id: C,
) -> GetChatAdministrators
where
C: Into<ChatId>,
{
GetChatAdministrators::new(self, chat_id)
}
pub fn get_chat_members_count<C>(&self, chat_id: C) -> GetChatMembersCount
where
C: Into<ChatId>,
@ -366,21 +383,21 @@ impl Bot {
SetChatTitle::new(self, chat_id, title)
}
pub fn delete_chat_photo<C>(
&self,
chat_id: C,
) -> DeleteChatPhoto
pub fn delete_chat_photo<C>(&self, chat_id: C) -> DeleteChatPhoto
where
C: Into<ChatId>,
{
DeleteChatPhoto::new(self, chat_id)
}
pub fn set_chat_photo<C, P>(
&self,
chat_id: C,
photo: P,
) -> SetChatPhoto
pub fn leave_chat<C>(&self, chat_id: C) -> LeaveChat
where
C: Into<ChatId>,
{
LeaveChat::new(self, chat_id)
}
pub fn set_chat_photo<C, P>(&self, chat_id: C, photo: P) -> SetChatPhoto
where
C: Into<ChatId>,
P: Into<InputFile>,
@ -388,10 +405,7 @@ impl Bot {
SetChatPhoto::new(self, chat_id, photo)
}
pub fn export_chat_invite_link<C>(
&self,
chat_id: C,
) -> ExportCharInviteLink
pub fn export_chat_invite_link<C>(&self, chat_id: C) -> ExportCharInviteLink
where
C: Into<ChatId>,
{

0
src/dispatcher/simple/error_policy.rs → src/dispatching/dispatchers/filter/error_policy.rs
View file

61
src/dispatcher/simple/mod.rs → src/dispatching/dispatchers/filter/mod.rs
View file

@ -3,9 +3,9 @@ use futures::StreamExt;
use async_trait::async_trait;
use crate::{
dispatcher::{
filter::Filter, handler::Handler, simple::error_policy::ErrorPolicy,
updater::Updater,
dispatching::{
dispatchers::filter::error_policy::ErrorPolicy, filters::Filter,
handler::Handler, updater::Updater,
},
types::{CallbackQuery, ChosenInlineResult, Message, Update, UpdateKind},
};
@ -17,13 +17,13 @@ type Handlers<'a, T, E> =
/// Dispatcher that dispatches updates from telegram.
///
/// This is 'simple' implementation with following limitations:
/// This is 'filter' implementation with following limitations:
/// - Error (`E` generic parameter) _must_ implement [`std::fmt::Debug`]
/// - All 'handlers' are boxed
/// - Handler's fututres are also boxed
/// - [Custom error policy] is also boxed
/// - All errors from [updater] are ignored (TODO: remove this limitation)
/// - All handlers executed in order (this means that in dispatcher have 2
/// - All handlers executed in order (this means that in dispatching have 2
/// upadtes it will first execute some handler into complition with first
/// update and **then** search for handler for second update, this is probably
/// wrong)
@ -37,8 +37,8 @@ type Handlers<'a, T, E> =
/// async fn run() {
/// use std::convert::Infallible;
/// use telebofr::{
/// dispatcher::{
/// simple::{error_policy::ErrorPolicy, Dispatcher},
/// dispatching::{
/// dispatchers::filter::{error_policy::ErrorPolicy, FilterDispatcher},
/// updater::polling,
/// },
/// };
@ -49,9 +49,9 @@ type Handlers<'a, T, E> =
///
/// let bot = Bot::new("TOKEN");
///
/// // create dispatcher which handlers can't fail
/// // create dispatching which handlers can't fail
/// // with error policy that just ignores all errors (that can't ever happen)
/// let mut dp = Dispatcher::<Infallible>::new(ErrorPolicy::Ignore)
/// let mut dp = FilterDispatcher::<Infallible>::new(ErrorPolicy::Ignore)
/// // Add 'handler' that will handle all messages sent to the bot
/// .message_handler(true, |mes: Message| {
/// async move { println!("New message: {:?}", mes) }
@ -67,9 +67,9 @@ type Handlers<'a, T, E> =
///
/// [`std::fmt::Debug`]: std::fmt::Debug
/// [Custom error policy]:
/// crate::dispatcher::simple::error_policy::ErrorPolicy::Custom [updater]:
/// crate::dispatcher::updater
pub struct Dispatcher<'a, E> {
/// crate::dispatching::filter::error_policy::ErrorPolicy::Custom [updater]:
/// crate::dispatching::updater
pub struct FilterDispatcher<'a, E> {
message_handlers: Handlers<'a, Message, E>,
edited_message_handlers: Handlers<'a, Message, E>,
channel_post_handlers: Handlers<'a, Message, E>,
@ -80,12 +80,12 @@ pub struct Dispatcher<'a, E> {
error_policy: ErrorPolicy<'a, E>,
}
impl<'a, E> Dispatcher<'a, E>
impl<'a, E> FilterDispatcher<'a, E>
where
E: std::fmt::Debug, // TODO: Is this really necessary?
{
pub fn new(error_policy: ErrorPolicy<'a, E>) -> Self {
Dispatcher {
FilterDispatcher {
message_handlers: Vec::new(),
edited_message_handlers: Vec::new(),
channel_post_handlers: Vec::new(),
@ -197,16 +197,29 @@ where
match kind {
UpdateKind::Message(mes) => {
self.handle(mes, &self.message_handlers).await;
self.handle(mes, &self.message_handlers)
.await;
}
UpdateKind::EditedMessage(mes) => {
self.handle(mes, &self.edited_message_handlers).await;
self.handle(
mes,
&self.edited_message_handlers,
)
.await;
}
UpdateKind::ChannelPost(post) => {
self.handle(post, &self.channel_post_handlers).await;
self.handle(
post,
&self.channel_post_handlers,
)
.await;
}
UpdateKind::EditedChannelPost(post) => {
self.handle(post, &self.edited_channel_post_handlers).await;
self.handle(
post,
&self.edited_channel_post_handlers,
)
.await;
}
UpdateKind::InlineQuery(query) => {
self.handle(query, &self.inline_query_handlers).await;
@ -249,13 +262,13 @@ where
}
#[async_trait(? Send)]
impl<'a, U, E> crate::dispatcher::Dispatcher<'a, U> for Dispatcher<'a, E>
impl<'a, U, E> crate::dispatching::Dispatcher<'a, U> for FilterDispatcher<'a, E>
where
E: std::fmt::Debug,
U: Updater + 'a,
{
async fn dispatch(&'a mut self, updater: U) {
Dispatcher::dispatch(self, updater).await
FilterDispatcher::dispatch(self, updater).await
}
}
@ -269,8 +282,10 @@ mod tests {
use futures::Stream;
use crate::{
dispatcher::{
simple::{error_policy::ErrorPolicy, Dispatcher},
dispatching::{
dispatchers::filter::{
error_policy::ErrorPolicy, FilterDispatcher,
},
updater::StreamUpdater,
},
types::{
@ -284,7 +299,7 @@ mod tests {
let counter = &AtomicI32::new(0);
let counter2 = &AtomicI32::new(0);
let mut dp = Dispatcher::<Infallible>::new(ErrorPolicy::Ignore)
let mut dp = FilterDispatcher::<Infallible>::new(ErrorPolicy::Ignore)
.message_handler(true, |_mes: Message| {
async move {
counter.fetch_add(1, Ordering::SeqCst);

3
src/dispatching/dispatchers/mod.rs Normal file
View file

@ -0,0 +1,3 @@
pub use filter::FilterDispatcher;
pub mod filter;

50
src/dispatcher/filter.rs → src/dispatching/filters.rs
View file

@ -6,7 +6,7 @@ pub trait Filter<T> {
}
/// ```
/// use telebofr::dispatcher::filter::Filter;
/// use telebofr::dispatching::filters::Filter;
///
/// let closure = |i: &i32| -> bool { *i >= 42 };
/// assert!(closure.test(&42));
@ -22,7 +22,7 @@ impl<T, F: Fn(&T) -> bool> Filter<T> for F {
}
/// ```
/// use telebofr::dispatcher::filter::Filter;
/// use telebofr::dispatching::filters::Filter;
///
/// assert!(true.test(&()));
/// assert_eq!(false.test(&()), false);
@ -42,7 +42,7 @@ impl<T> Filter<T> for bool {
///
/// ## Examples
/// ```
/// use telebofr::dispatcher::filter::{And, Filter};
/// use telebofr::dispatching::filters::{And, Filter};
///
/// // Note: bool can be treated as `Filter` that always return self.
/// assert_eq!(And::new(true, false).test(&()), false);
@ -73,13 +73,13 @@ where
///
/// ## Examples
/// ```
/// use telebofr::dispatcher::filter::{and, Filter};
/// use telebofr::dispatching::filters::{and, Filter};
///
/// assert!(and(true, true).test(&()));
/// assert_eq!(and(true, false).test(&()), false);
/// ```
///
/// [`And::new`]: crate::dispatcher::filter::And::new
/// [`And::new`]: crate::dispatching::filter::And::new
pub fn and<A, B>(a: A, b: B) -> And<A, B> {
And::new(a, b)
}
@ -93,7 +93,7 @@ pub fn and<A, B>(a: A, b: B) -> And<A, B> {
///
/// ## Examples
/// ```
/// use telebofr::dispatcher::filter::{Filter, Or};
/// use telebofr::dispatching::filters::{Filter, Or};
///
/// // Note: bool can be treated as `Filter` that always return self.
/// assert!(Or::new(true, false).test(&()));
@ -124,13 +124,13 @@ where
///
/// ## Examples
/// ```
/// use telebofr::dispatcher::filter::{or, Filter};
/// use telebofr::dispatching::filters::{or, Filter};
///
/// assert!(or(true, false).test(&()));
/// assert_eq!(or(false, false).test(&()), false);
/// ```
///
/// [`Or::new`]: crate::dispatcher::filter::Or::new
/// [`Or::new`]: crate::dispatching::filter::Or::new
pub fn or<A, B>(a: A, b: B) -> Or<A, B> {
Or::new(a, b)
}
@ -141,7 +141,7 @@ pub fn or<A, B>(a: A, b: B) -> Or<A, B> {
///
/// ## Examples
/// ```
/// use telebofr::dispatcher::filter::{Filter, Not};
/// use telebofr::dispatching::filters::{Filter, Not};
///
/// // Note: bool can be treated as `Filter` that always return self.
/// assert!(Not::new(false).test(&()));
@ -169,13 +169,13 @@ where
///
/// ## Examples
/// ```
/// use telebofr::dispatcher::filter::{not, Filter};
/// use telebofr::dispatching::filters::{not, Filter};
///
/// assert!(not(false).test(&()));
/// assert_eq!(not(true).test(&()), false);
/// ```
///
/// [`Not::new`]: crate::dispatcher::filter::Not::new
/// [`Not::new`]: crate::dispatching::filter::Not::new
pub fn not<A>(a: A) -> Not<A> {
Not::new(a)
}
@ -187,7 +187,7 @@ pub fn not<A>(a: A) -> Not<A> {
///
/// ## Examples
/// ```
/// use telebofr::{all, dispatcher::filter::Filter};
/// use telebofr::{all, dispatching::filters::Filter};
///
/// assert!(all![true].test(&()));
/// assert!(all![true, true].test(&()));
@ -199,12 +199,12 @@ pub fn not<A>(a: A) -> Not<A> {
/// assert_eq!(all![false, false].test(&()), false);
/// ```
///
/// [filter]: crate::dispatcher::filter::Filter
/// [filter]: crate::dispatching::filter::Filter
#[macro_export]
macro_rules! all {
($one:expr) => { $one };
($head:expr, $($tail:tt)+) => {
$crate::dispatcher::filter::And::new(
$crate::dispatching::filters::And::new(
$head,
$crate::all!($($tail)+)
)
@ -218,7 +218,7 @@ macro_rules! all {
///
/// ## Examples
/// ```
/// use telebofr::{any, dispatcher::filter::Filter};
/// use telebofr::{any, dispatching::filters::Filter};
///
/// assert!(any![true].test(&()));
/// assert!(any![true, true].test(&()));
@ -230,12 +230,12 @@ macro_rules! all {
/// assert_eq!(any![false, false, false].test(&()), false);
/// ```
///
/// [filter]: crate::dispatcher::filter::Filter
/// [filter]: crate::dispatching::filter::Filter
#[macro_export]
macro_rules! any {
($one:expr) => { $one };
($head:expr, $($tail:tt)+) => {
$crate::dispatcher::filter::Or::new(
$crate::dispatching::filters::Or::new(
$head,
$crate::all!($($tail)+)
)
@ -246,7 +246,7 @@ macro_rules! any {
///
/// ## Examples
/// ```
/// use telebofr::dispatcher::filter::{f, And, Filter, Or, F};
/// use telebofr::dispatching::filters::{f, And, Filter, Or, F};
///
/// let flt1 = |i: &i32| -> bool { *i > 17 };
/// let flt2 = |i: &i32| -> bool { *i < 42 };
@ -277,7 +277,7 @@ pub struct F<A>(A);
/// Constructor fn for [F]
///
/// [F]: crate::dispatcher::filter::F;
/// [F]: crate::dispatching::filter::F;
pub fn f<A>(a: A) -> F<A> {
F(a)
}
@ -314,7 +314,7 @@ pub trait FilterExt<T> {
///
/// ## Examples
/// ```
/// use telebofr::dispatcher::filter::{Filter, FilterExt};
/// use telebofr::dispatching::filters::{Filter, FilterExt};
///
/// let flt = |i: &i32| -> bool { *i > 0 };
/// let flt = flt.not();
@ -322,7 +322,7 @@ pub trait FilterExt<T> {
/// assert_eq!(flt.test(&1), false);
/// ```
///
/// [`Not::new`]: crate::dispatcher::filter::Not::new
/// [`Not::new`]: crate::dispatching::filter::Not::new
fn not(self) -> Not<Self>
where
Self: Sized,
@ -334,7 +334,7 @@ pub trait FilterExt<T> {
///
/// ## Examples
/// ```
/// use telebofr::dispatcher::filter::{Filter, FilterExt};
/// use telebofr::dispatching::filters::{Filter, FilterExt};
///
/// let flt = |i: &i32| -> bool { *i > 0 };
/// let flt = flt.and(|i: &i32| *i < 42);
@ -344,7 +344,7 @@ pub trait FilterExt<T> {
/// assert_eq!(flt.test(&43), false);
/// ```
///
/// [`Not::new`]: crate::dispatcher::filter::And::new
/// [`Not::new`]: crate::dispatching::filter::And::new
fn and<B>(self, other: B) -> And<Self, B>
where
Self: Sized,
@ -356,7 +356,7 @@ pub trait FilterExt<T> {
///
/// ## Examples
/// ```
/// use telebofr::dispatcher::filter::{Filter, FilterExt};
/// use telebofr::dispatching::filters::{Filter, FilterExt};
///
/// let flt = |i: &i32| -> bool { *i < 0 };
/// let flt = flt.or(|i: &i32| *i > 42);
@ -366,7 +366,7 @@ pub trait FilterExt<T> {
/// assert_eq!(flt.test(&17), false);
/// ```
///
/// [`Not::new`]: crate::dispatcher::filter::Or::new
/// [`Not::new`]: crate::dispatching::filter::Or::new
fn or<B>(self, other: B) -> Or<Self, B>
where
Self: Sized,

0
src/dispatcher/handler.rs → src/dispatching/handler.rs
View file

6
src/dispatcher/mod.rs → src/dispatching/mod.rs
View file

@ -1,12 +1,12 @@
//! Update dispatching.
use async_trait::async_trait;
pub use filter::Filter;
pub use filters::Filter;
pub use handler::Handler;
pub mod filter;
pub mod dispatchers;
pub mod filters;
pub mod handler;
pub mod simple;
pub mod updater;
#[async_trait(? Send)]

0
src/dispatcher/updater.rs → src/dispatching/updater.rs
View file

2
src/lib.rs
View file

@ -12,6 +12,6 @@ mod errors;
mod network;
mod bot;
pub mod dispatcher;
pub mod dispatching;
pub mod requests;
pub mod types;

8
src/network/telegram_response.rs
View file

@ -1,7 +1,9 @@
use reqwest::StatusCode;
use crate::{
requests::ResponseResult, types::ResponseParameters, RequestError,
requests::ResponseResult,
types::{False, ResponseParameters, True},
RequestError,
};
#[derive(Deserialize)]
@ -10,14 +12,14 @@ pub enum TelegramResponse<R> {
Ok {
/// A dummy field. Used only for deserialization.
#[allow(dead_code)]
ok: bool, // TODO: True type
ok: True,
result: R,
},
Err {
/// A dummy field. Used only for deserialization.
#[allow(dead_code)]
ok: bool, // TODO: False type
ok: False,
description: String,
error_code: u16,

3
src/requests/answer_callback_query.rs
View file

@ -1,10 +1,11 @@
use async_trait::async_trait;
use crate::{
bot::Bot,
network,
requests::{Request, ResponseResult},
types::True,
};
use async_trait::async_trait;
/// Use this method to send answers to callback queries sent from inline
/// keyboards. The answer will be displayed to the user as a notification at the

19
src/requests/delete_chat_photo.rs
View file

@ -1,16 +1,18 @@
use async_trait::async_trait;
use crate::bot::Bot;
use crate::types::{ChatId, True};
use crate::requests::{ResponseResult, Request};
use crate::network;
use crate::{
bot::Bot,
network,
requests::{Request, ResponseResult},
types::{ChatId, True},
};
#[derive(Debug, Clone, Serialize)]
pub struct DeleteChatPhoto<'a> {
#[serde(skip_serializing)]
bot: &'a Bot,
chat_id: ChatId
chat_id: ChatId,
}
#[async_trait]
@ -28,15 +30,16 @@ impl DeleteChatPhoto<'_> {
self.bot.client(),
self.bot.token(),
"deleteChatPhoto",
&self
).await
&self,
)
.await
}
}
impl<'a> DeleteChatPhoto<'a> {
pub(crate) fn new<C>(bot: &'a Bot, chat_id: C) -> Self
where
C: Into<ChatId>
C: Into<ChatId>,
{
Self {
bot,

3
src/requests/delete_chat_sticker_set.rs
View file

@ -1,10 +1,11 @@
use async_trait::async_trait;
use crate::{
bot::Bot,
network,
requests::{Request, ResponseResult},
types::{ChatId, True},
};
use async_trait::async_trait;
/// Use this method to delete a group sticker set from a supergroup. The bot
/// must be an administrator in the chat for this to work and must have the

22
src/requests/export_chat_invite_link.rs
View file

@ -1,16 +1,18 @@
use async_trait::async_trait;
use crate::bot::Bot;
use crate::types::ChatId;
use crate::requests::{ResponseResult, Request};
use crate::network;
use crate::{
bot::Bot,
network,
requests::{Request, ResponseResult},
types::ChatId,
};
#[derive(Debug, Clone, Serialize)]
pub struct ExportCharInviteLink<'a> {
#[serde(skip_serializing)]
bot: &'a Bot,
chat_id: ChatId
chat_id: ChatId,
}
#[async_trait]
@ -28,15 +30,16 @@ impl ExportCharInviteLink<'_> {
self.bot.client(),
self.bot.token(),
"exportChatInviteLink",
&self
).await
&self,
)
.await
}
}
impl<'a> ExportCharInviteLink<'a> {
pub(crate) fn new<C>(bot: &'a Bot, chat_id: C) -> Self
where
C: Into<ChatId>
C: Into<ChatId>,
{
Self {
bot,
@ -64,7 +67,8 @@ mod tests {
let method = ExportCharInviteLink::new(&bot, chat_id);
let expected = r#"{"chat_id":123}"#;
let actual = serde_json::to_string::<ExportCharInviteLink>(&method).unwrap();
let actual =
serde_json::to_string::<ExportCharInviteLink>(&method).unwrap();
assert_eq!(actual, expected);
}
}

14
src/requests/get_chat.rs
View file

@ -42,11 +42,21 @@ impl GetChat<'_> {
}
impl<'a> GetChat<'a> {
pub fn chat_id<C>(mut self, value: C) -> Self
pub(crate) fn new<F>(bot: &'a Bot, chat_id: F) -> Self
where
F: Into<ChatId>,
{
Self {
bot,
chat_id: chat_id.into(),
}
}
pub fn chat_id<C>(mut self, chat_id: C) -> Self
where
C: Into<ChatId>,
{
self.chat_id = value.into();
self.chat_id = chat_id.into();
self
}
}

64
src/requests/get_chat_administrators.rs Normal file
View file

@ -0,0 +1,64 @@
use async_trait::async_trait;
use crate::{
bot::Bot,
network,
requests::{Request, ResponseResult},
types::{ChatId, ChatMember},
};
/// Use this method to get a list of administrators in a chat. On success,
/// returns an Array of ChatMember objects that contains information about all
/// chat administrators except other bots. If the chat is a group or a
/// supergroup and no administrators were appointed, only the creator will be
/// returned
#[derive(Debug, Clone, Serialize)]
pub struct GetChatAdministrators<'a> {
#[serde(skip_serializing)]
bot: &'a Bot,
/// Unique identifier for the target chat or username of the target
/// supergroup or channel (in the format @channelusername)
chat_id: ChatId,
}
#[async_trait]
impl Request for GetChatAdministrators<'_> {
type Output = Vec<ChatMember>;
async fn send_boxed(self) -> ResponseResult<Self::Output> {
self.send().await
}
}
impl GetChatAdministrators<'_> {
async fn send(&self) -> ResponseResult<Vec<ChatMember>> {
network::request_json(
self.bot.client(),
self.bot.token(),
"getChatAdministrators",
&self,
)
.await
}
}
impl<'a> GetChatAdministrators<'a> {
pub(crate) fn new<C>(bot: &'a Bot, chat_id: C) -> Self
where
C: Into<ChatId>,
{
Self {
bot,
chat_id: chat_id.into(),
}
}
pub fn chat_id<C>(mut self, value: C) -> Self
where
C: Into<ChatId>,
{
self.chat_id = value.into();
self
}
}

3
src/requests/get_chat_member.rs
View file

@ -1,10 +1,11 @@
use async_trait::async_trait;
use crate::{
bot::Bot,
network,
requests::{Request, ResponseResult},
types::{ChatId, ChatMember},
};
use async_trait::async_trait;
/// Use this method to get information about a member of a chat. Returns a
/// ChatMember object on success.

2
src/requests/get_me.rs
View file

@ -8,7 +8,7 @@ use crate::{
};
#[derive(Debug, Clone)]
/// A simple method for testing your bot's auth token. Requires no parameters.
/// A filter method for testing your bot's auth token. Requires no parameters.
/// Returns basic information about the bot in form of a [`User`] object.
pub struct GetMe<'a> {
bot: &'a Bot,

59
src/requests/leave_chat.rs Normal file
View file

@ -0,0 +1,59 @@
use async_trait::async_trait;
use crate::{
bot::Bot,
network,
requests::{Request, ResponseResult},
types::ChatId,
};
/// Use this method for your bot to leave a group, supergroup or channel.
/// Returns True on success.
#[derive(Debug, Clone, Serialize)]
pub struct LeaveChat<'a> {
#[serde(skip_serializing)]
bot: &'a Bot,
/// Unique identifier for the target chat or username
/// of the target supergroup or channel (in the format @channelusername)
chat_id: ChatId,
}
#[async_trait]
impl Request for LeaveChat<'_> {
type Output = bool;
async fn send_boxed(self) -> ResponseResult<Self::Output> {
self.send().await
}
}
impl LeaveChat<'_> {
pub async fn send(self) -> ResponseResult<bool> {
network::request_json(
self.bot.client(),
self.bot.token(),
"leaveChat",
&self,
)
.await
}
}
impl<'a> LeaveChat<'a> {
pub(crate) fn new<F>(bot: &'a Bot, chat_id: F) -> Self
where
F: Into<ChatId>,
{
Self {
bot,
chat_id: chat_id.into(),
}
}
pub fn chat_id<C>(mut self, chat_id: C) -> Self
where
C: Into<ChatId>,
{
self.chat_id = chat_id.into();
self
}
}

10
src/requests/mod.rs
View file

@ -1,8 +1,5 @@
//! API requests.
use async_trait::async_trait;
use serde::de::DeserializeOwned;
pub use answer_callback_query::*;
pub use answer_pre_checkout_query::*;
pub use answer_shipping_query::*;
@ -12,6 +9,7 @@ pub use edit_message_live_location::*;
pub use export_chat_invite_link::*;
pub use forward_message::*;
pub use get_chat::*;
pub use get_chat_administrators::*;
pub use get_chat_member::*;
pub use get_chat_members_count::*;
pub use get_file::*;
@ -19,6 +17,7 @@ pub use get_me::*;
pub use get_updates::*;
pub use get_user_profile_photos::*;
pub use kick_chat_member::*;
pub use leave_chat::*;
pub use pin_chat_message::*;
pub use promote_chat_member::*;
pub use restrict_chat_member::*;
@ -57,6 +56,7 @@ mod edit_message_live_location;
mod export_chat_invite_link;
mod forward_message;
mod get_chat;
mod get_chat_administrators;
mod get_chat_member;
mod get_chat_members_count;
mod get_file;
@ -64,6 +64,7 @@ mod get_me;
mod get_updates;
mod get_user_profile_photos;
mod kick_chat_member;
mod leave_chat;
mod pin_chat_message;
mod promote_chat_member;
mod restrict_chat_member;
@ -90,6 +91,9 @@ mod stop_message_live_location;
mod unban_chat_member;
mod unpin_chat_message;
use async_trait::async_trait;
use serde::de::DeserializeOwned;
/// A type that is returned from `Request::send_boxed`.
pub type ResponseResult<T> = Result<T, crate::RequestError>;

33
src/requests/set_chat_permissions.rs
View file

@ -1,9 +1,11 @@
use async_trait::async_trait;
use crate::bot::Bot;
use crate::types::{ChatId, ChatPermissions, True};
use crate::requests::{ResponseResult, Request};
use crate::network;
use crate::{
bot::Bot,
network,
requests::{Request, ResponseResult},
types::{ChatId, ChatPermissions, True},
};
#[derive(Debug, Clone, Serialize)]
pub struct SetChatPermissions<'a> {
@ -11,7 +13,7 @@ pub struct SetChatPermissions<'a> {
bot: &'a Bot,
chat_id: ChatId,
permissions: ChatPermissions
permissions: ChatPermissions,
}
#[async_trait]
@ -29,17 +31,14 @@ impl SetChatPermissions<'_> {
self.bot.client(),
self.bot.token(),
"setChatPermissions",
&self
).await
&self,
)
.await
}
}
impl<'a> SetChatPermissions<'a> {
pub(crate) fn new<C, CP>(
bot: &'a Bot,
chat_id: C,
permissions: CP,
) -> Self
pub(crate) fn new<C, CP>(bot: &'a Bot, chat_id: C, permissions: CP) -> Self
where
C: Into<ChatId>,
CP: Into<ChatPermissions>,
@ -61,7 +60,7 @@ impl<'a> SetChatPermissions<'a> {
pub fn permissions<CP>(mut self, permissions: CP) -> Self
where
CP: Into<ChatPermissions>
CP: Into<ChatPermissions>,
{
self.permissions = permissions.into();
self
@ -84,12 +83,14 @@ mod tests {
can_add_web_page_previews: None,
can_change_info: None,
can_invite_users: None,
can_pin_messages: None
can_pin_messages: None,
};
let method = SetChatPermissions::new(&bot, chat_id, permissions);
let expected = r#"{"chat_id":123,"permissions":{"can_send_messages":true}}"#;
let actual = serde_json::to_string::<SetChatPermissions>(&method).unwrap();
let expected =
r#"{"chat_id":123,"permissions":{"can_send_messages":true}}"#;
let actual =
serde_json::to_string::<SetChatPermissions>(&method).unwrap();
assert_eq!(actual, expected);
}
}

23
src/requests/set_chat_photo.rs
View file

@ -1,10 +1,11 @@
use async_trait::async_trait;
use crate::bot::Bot;
use crate::types::{ChatId, True, InputFile};
use crate::requests::{Request, ResponseResult};
use crate::network;
use crate::requests::form_builder::FormBuilder;
use crate::{
bot::Bot,
network,
requests::{form_builder::FormBuilder, Request, ResponseResult},
types::{ChatId, InputFile, True},
};
#[derive(Debug, Clone, Serialize)]
pub struct SetChatPhoto<'a> {
@ -35,16 +36,13 @@ impl SetChatPhoto<'_> {
self.bot.token(),
"setChatPhoto",
params.build(),
).await
)
.await
}
}
impl<'a> SetChatPhoto<'a> {
pub(crate) fn new<C, P>(
bot: &'a Bot,
chat_id: C,
photo: P
) -> Self
pub(crate) fn new<C, P>(bot: &'a Bot, chat_id: C, photo: P) -> Self
where
C: Into<ChatId>,
P: Into<InputFile>,
@ -82,7 +80,8 @@ mod tests {
let bot = Bot::new("token");
let chat_id = 123;
let photo_url = "https://some_url".to_string();
let method = SetChatPhoto::new(&bot, chat_id, InputFile::Url(photo_url));
let method =
SetChatPhoto::new(&bot, chat_id, InputFile::Url(photo_url));
let expected = r#"{"chat_id":123,"photo":"https://some_url"}"#;
let actual = serde_json::to_string::<SetChatPhoto>(&method).unwrap();

3
src/requests/set_chat_sticker_set.rs
View file

@ -1,10 +1,11 @@
use async_trait::async_trait;
use crate::{
bot::Bot,
network,
requests::{Request, ResponseResult},
types::{ChatId, True},
};
use async_trait::async_trait;
/// Use this method to set a new group sticker set for a supergroup. The bot
/// must be an administrator in the chat for this to work and must have the

12
src/requests/set_chat_title.rs
View file

@ -38,14 +38,10 @@ impl SetChatTitle<'_> {
}
impl<'a> SetChatTitle<'a> {
pub(crate) fn new<C, T>(
bot: &'a Bot,
chat_id: C,
title: T
) -> Self
where
C: Into<ChatId>,
T: Into<String>,
pub(crate) fn new<C, T>(bot: &'a Bot, chat_id: C, title: T) -> Self
where
C: Into<ChatId>,
T: Into<String>,
{
Self {
bot,

2
src/types/keyboard_button.rs
View file

@ -1,4 +1,4 @@
/// This object represents one button of the reply keyboard. For simple text
/// This object represents one button of the reply keyboard. For filter text
/// buttons String can be used instead of this object to specify text of the
/// button. Optional fields are mutually exclusive.
#[derive(Debug, Serialize, Deserialize, Hash, PartialEq, Eq, Clone)]

80
src/types/mod.rs
View file

@ -13,49 +13,14 @@ pub use chat_photo::*;
pub use chosen_inline_result::*;
pub use contact::*;
pub use document::*;
pub use encrypted_credentials::*;
pub use encrypted_passport_element::*;
pub use file::*;
pub use force_reply::*;
pub use game::*;
pub use game_high_score::*;
pub use inline_keyboard_button::*;
pub use inline_keyboard_markup::*;
pub use input_file::*;
pub use input_media::*;
pub use input_message_content::*;
pub use invoice::*;
pub use keyboard_button::*;
pub use label_price::*;
pub use location::*;
pub use login_url::*;
pub use mask_position::*;
pub use message::*;
pub use message_entity::*;
pub use order_info::*;
pub use parse_mode::*;
pub use photo_size::*;
pub use poll::*;
pub use pre_checkout_query::*;
pub use reply_keyboard_markup::*;
pub use reply_keyboard_remove::*;
pub use reply_markup::*;
pub use response_parameters::*;
pub use send_invoice::*;
pub use shipping_address::*;
pub use shipping_option::*;
pub use shipping_query::*;
pub use sticker::*;
pub use sticker_set::*;
pub use successful_payment::*;
pub use unit_true::*;
pub use update::*;
pub use user::*;
pub use user_profile_photos::*;
pub use venue::*;
pub use video::*;
pub use video_note::*;
pub use voice::*;
pub use webhook_info::*;
pub use inline_query::*;
pub use inline_query_result::*;
pub use inline_query_result_article::*;
@ -78,11 +43,45 @@ pub use inline_query_result_photo::*;
pub use inline_query_result_venue::*;
pub use inline_query_result_video::*;
pub use inline_query_result_voice::*;
pub use encrypted_credentials::*;
pub use encrypted_passport_element::*;
pub use input_file::*;
pub use input_media::*;
pub use input_message_content::*;
pub use invoice::*;
pub use keyboard_button::*;
pub use label_price::*;
pub use location::*;
pub use login_url::*;
pub use mask_position::*;
pub use message::*;
pub use message_entity::*;
pub use order_info::*;
pub use parse_mode::*;
pub use passport_data::*;
pub use passport_file::*;
pub use photo_size::*;
pub use poll::*;
pub use pre_checkout_query::*;
pub use reply_keyboard_markup::*;
pub use reply_keyboard_remove::*;
pub use reply_markup::*;
pub use response_parameters::*;
pub use send_invoice::*;
pub use shipping_address::*;
pub use shipping_option::*;
pub use shipping_query::*;
pub use sticker::*;
pub use sticker_set::*;
pub use successful_payment::*;
pub use unit_false::*;
pub use unit_true::*;
pub use update::*;
pub use user::*;
pub use user_profile_photos::*;
pub use venue::*;
pub use video::*;
pub use video_note::*;
pub use voice::*;
pub use webhook_info::*;
mod animation;
mod audio;
@ -130,6 +129,7 @@ mod shipping_query;
mod sticker;
mod sticker_set;
mod successful_payment;
mod unit_false;
mod unit_true;
mod update;
mod user;

80
src/types/unit_false.rs Normal file
View file

@ -0,0 +1,80 @@
use serde::{de::Visitor, Deserialize, Deserializer, Serialize, Serializer};
#[derive(Copy, Clone, Debug, Default, Eq, Hash, PartialEq)]
pub struct False;
impl std::convert::TryFrom<bool> for False {
type Error = ();
fn try_from(value: bool) -> Result<Self, Self::Error> {
#[allow(clippy::match_bool)]
match value {
true => Err(()),
false => Ok(False),
}
}
}
impl<'de> Deserialize<'de> for False {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_bool(FalseVisitor)
}
}
struct FalseVisitor;
impl<'de> Visitor<'de> for FalseVisitor {
type Value = False;
fn expecting(
&self,
formatter: &mut std::fmt::Formatter,
) -> std::fmt::Result {
write!(formatter, "bool, equal to `false`")
}
fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
#[allow(clippy::match_bool)]
match value {
true => Err(E::custom("expected `false`, found `true`")),
false => Ok(False),
}
}
}
impl Serialize for False {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_bool(false)
}
}
#[cfg(test)]
mod tests {
use serde_json::{from_str, to_string};
use super::False;
#[test]
fn unit_false_de() {
let json = "false";
let expected = False;
let actual = from_str(json).unwrap();
assert_eq!(expected, actual);
}
#[test]
fn unit_false_se() {
let actual = to_string(&False).unwrap();
let expected = "false";
assert_eq!(expected, actual);
}
}

2
src/types/unit_true.rs
View file

@ -3,7 +3,7 @@ use serde::{
ser::{Serialize, Serializer},
};
#[derive(Copy, Clone, Debug, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, PartialEq)]
pub struct True;
impl std::convert::TryFrom<bool> for True {