OpenSource/teloxide
OpenSource/teloxide
1
0
Fork 0
mirror of https://github.com/teloxide/teloxide.git synced 2024-12-22 22:46:39 +01:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #31 from Mr-Andersen/dev

Browse source 
+request/PinChatMessage, +type/EncryptedPassportElement
This commit is contained in:
Andrew Andersen 2019-09-24 20:05:01 +03:00 committed by GitHub
commit bc5b43d68b
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 112 additions and 131 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/requests/mod.rs
View file

@ -14,7 +14,8 @@ pub use self::{
forward_message::ForwardMessage, get_chat::GetChat, get_file::GetFile,
get_me::GetMe, get_updates::GetUpdates,
get_user_profile_photos::GetUserProfilePhotos,
kick_chat_member::KickChatMember, restrict_chat_member::RestrictChatMember,
kick_chat_member::KickChatMember, pin_chat_message::PinChatMessage,
restrict_chat_member::RestrictChatMember,
send_audio::SendAudio, send_chat_action::SendChatAction,
send_contact::SendContact, send_location::SendLocation,
send_media_group::SendMediaGroup, send_message::SendMessage,
@ -89,6 +90,7 @@ mod get_me;
mod get_updates;
mod get_user_profile_photos;
mod kick_chat_member;
mod pin_chat_message;
mod restrict_chat_member;
mod send_audio;
mod send_chat_action;

47
src/requests/pin_chat_message.rs Normal file
View file

@ -0,0 +1,47 @@
use crate::requests::{ChatId, RequestContext, RequestFuture, ResponseResult, Request};
use crate::network;
/// Use this method to get up to date information about the chat
/// (current name of the user for one-on-one conversations,
/// current username of a user, group or channel, etc.).
/// Returns a Chat object on success.
#[derive(Debug, Clone, Serialize)]
pub struct PinChatMessage<'a> {
#[serde(skip_serializing)]
ctx: RequestContext<'a>,
/// Unique identifier for the target chat or username
/// of the target supergroup or channel (in the format @channelusername)
pub chat_id: ChatId,
pub message_id: i32,
pub disable_notification: Option<bool>
}
impl<'a> PinChatMessage<'a> {
pub(crate) fn new(
ctx: RequestContext<'a>, chat_id: ChatId, message_id: i32
) -> Self {
Self { ctx, chat_id, message_id, disable_notification: None }
}
pub fn disable_notification<T>(mut self, val: T) -> Self
where T: Into<bool>
{
self.disable_notification = Some(val.into());
self
}
}
impl<'a> Request<'a> for PinChatMessage<'a> {
type ReturnValue = bool; // TODO: change to unit type True
fn send(self) -> RequestFuture<'a, ResponseResult<Self::ReturnValue>> {
Box::pin(async move {
network::request_json(
&self.ctx.client,
&self.ctx.token,
"pinChatMessage",
&self,
).await
})
}
}

128
src/types/encrypted_passport_element.rs
View file

@ -1,75 +1,67 @@
use super::passport_file::PassportFile;
#[derive(Debug, Deserialize, Eq, Hash, PartialEq, Clone, Serialize)]
#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
pub struct EncryptedPassportElement {
#[serde(rename = "type")]
pub element_type: ElementType,
pub data: String,
pub phone_number: String,
pub email: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub files: Option<Vec<PassportFile>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub front_size: Option<PassportFile>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reverse_side: Option<PassportFile>,
#[serde(skip_serializing_if = "Option::is_none")]
pub selfie: Option<PassportFile>,
#[serde(skip_serializing_if = "Option::is_none")]
pub translation: Option<Vec<PassportFile>>,
pub hash: String,
#[serde(flatten)]
pub kind: EncryptedPassportElementKind
}
#[derive(Debug, Deserialize, Eq, Hash, PartialEq, Clone, Serialize)]
#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum ElementType {
PersonalData,
Passport,
DriverLicense,
IdentityCard,
Address,
UtilityBill,
BankStatement,
RentalAgreement,
PassportRegistration,
TemporaryRegistration,
PhoneNumber,
Email,
}
#[cfg(test)]
mod tests {
use super::super::{ElementType, EncryptedPassportElement, PassportFile};
#[test]
fn must_serialize_encrypted_passport_element_to_json() {
// given
let expected_json = r#"
{
"type":"passport_registration",
"data":"somedata",
"phone_number":"1313",
"email":"someemail",
"front_size":{"file_id":"someId","file_size":13,"file_date":13}
}"#
.replace("\n", "")
.replace(" ", "");
let passport_element = EncryptedPassportElement {
element_type: ElementType::PassportRegistration,
data: "somedata".to_string(),
phone_number: "1313".to_string(),
email: "someemail".to_string(),
files: None,
front_size: Some(PassportFile {
file_id: "someId".to_string(),
file_size: 13,
file_date: 13,
}),
reverse_side: None,
selfie: None,
translation: None,
};
let actual_json = serde_json::to_string(&passport_element).unwrap();
assert_eq!(actual_json, expected_json)
}
pub enum EncryptedPassportElementKind {
PersonalDetails {
data: String
},
Passport {
data: String,
front_side: PassportFile,
selfie: PassportFile,
translation: Option<Vec<PassportFile>>
},
DriverLicense {
data: String,
front_side: PassportFile,
reverse_side: PassportFile,
selfie: PassportFile,
translation: Option<Vec<PassportFile>>
},
IdentityCard {
data: String,
front_side: PassportFile,
reverse_side: PassportFile,
selfie: PassportFile,
translation: Option<Vec<PassportFile>>
},
InternalPassport {
data: String,
front_side: PassportFile,
selfie: PassportFile,
translation: Option<Vec<PassportFile>>
},
Address {
data: String
},
UtilityBill {
files: Vec<PassportFile>,
translation: Option<Vec<PassportFile>>
},
BankStatement {
files: Vec<PassportFile>,
translation: Option<Vec<PassportFile>>
},
RentalAgreement {
files: Vec<PassportFile>,
translation: Option<Vec<PassportFile>>
},
PassportRegistration {
files: Vec<PassportFile>,
translation: Option<Vec<PassportFile>>
},
TemporaryRegistration {
files: Vec<PassportFile>,
translation: Option<Vec<PassportFile>>
},
PhoneNumber { phone_number: String },
Email { email: String }
}

2
src/types/message.rs
View file

@ -15,7 +15,7 @@ pub struct Message {
}
impl Message {
fn text(&self) -> Option<&str> {
pub fn text(&self) -> Option<&str> {
if let MessageKind::Common {
media_kind: MediaKind::Text { ref text, .. },
..

2
src/types/mod.rs
View file

@ -12,7 +12,7 @@ pub use self::{
contact::Contact,
document::Document,
encrypted_credintials::EncryptedCredentials,
encrypted_passport_element::{ElementType, EncryptedPassportElement},
encrypted_passport_element::{EncryptedPassportElement, EncryptedPassportElementKind},
file::File,
force_reply::ForceReply,
game::Game,

60
src/types/passport_data.rs
View file

@ -6,63 +6,3 @@ pub struct PassportData {
pub data: Vec<EncryptedPassportElement>,
pub credentials: EncryptedCredentials,
}
#[cfg(test)]
mod tests {
use super::super::{ElementType, PassportFile};
use super::*;
#[test]
fn must_serialize_passport_data_to_json() {
let expected_json = r#"{
"data":
[
{
"type":"passport_registration",
"data":"somedata",
"phone_number":"1313",
"email":"someemail",
"front_size":
{
"file_id":"someId",
"file_size":13,
"file_date":13
}
}
],
"credentials":
{
"data":"someData",
"hash":"1122",
"secret":"secret"
}
}"#
.replace("\n", "")
.replace(" ", "");
let passport_data = PassportData {
data: vec![EncryptedPassportElement {
element_type: ElementType::PassportRegistration,
data: "somedata".to_string(),
phone_number: "1313".to_string(),
email: "someemail".to_string(),
files: None,
front_size: Some(PassportFile {
file_id: "someId".to_string(),
file_size: 13,
file_date: 13,
}),
reverse_side: None,
selfie: None,
translation: None,
}],
credentials: EncryptedCredentials {
data: "someData".to_string(),
hash: "1122".to_string(),
secret: "secret".to_string(),
},
};
let actual_json = serde_json::to_string(&passport_data).unwrap();
assert_eq!(actual_json, expected_json)
}
}