mod decrypt;
use chrono::{DateTime, Utc};
use serde::{Deserialize, Deserializer, Serialize};
pub use decrypt::{Decrypt, GetPhoneNumber};
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct Credentials {
#[serde(rename = "openid")]
open_id: String,
session_key: String,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct AccessToken {
#[serde(rename = "access_token")]
inner: String,
#[serde(
rename = "expires_in",
deserialize_with = "AccessToken::deserialize_expires_in"
)]
expired_at: DateTime<Utc>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct UserInfo {
nick_name: String,
gender: u8,
city: String,
province: String,
country: String,
avatar_url: String,
watermark: Watermark,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct PhoneInfo {
#[serde(rename = "phone_info")]
inner: PhoneInfoInner,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
struct PhoneInfoInner {
phone_number: String,
pure_phone_number: String,
country_code: String,
watermark: Watermark,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct Watermark {
#[serde(rename = "appid")]
app_id: String,
timestamp: u64,
}
impl Credentials {
pub fn open_id(&self) -> &str {
&self.open_id
}
}
impl UserInfo {
pub fn nick_name(&self) -> &str {
&self.nick_name
}
pub fn gender(&self) -> u8 {
self.gender
}
pub fn city(&self) -> &str {
&self.city
}
pub fn province(&self) -> &str {
&self.province
}
pub fn country(&self) -> &str {
&self.country
}
pub fn avatar_url(&self) -> &str {
&self.avatar_url
}
pub fn watermark(&self) -> &Watermark {
&self.watermark
}
}
impl PhoneInfo {
pub fn phone_number(&self) -> &str {
&self.inner.phone_number
}
pub fn pure_phone_number(&self) -> &str {
&self.inner.pure_phone_number
}
pub fn country_code(&self) -> &str {
&self.inner.country_code
}
pub fn watermark(&self) -> &Watermark {
&self.inner.watermark
}
}
impl Watermark {
pub fn app_id(&self) -> &str {
&self.app_id
}
pub fn timestamp(&self) -> u64 {
self.timestamp
}
}
impl AccessToken {
pub fn is_expired(&self) -> bool {
self.expired_at < Utc::now()
}
fn deserialize_expires_in<'de, D>(deserializer: D) -> Result<DateTime<Utc>, D::Error>
where
D: Deserializer<'de>,
{
use chrono::Duration;
let seconds = i64::deserialize(deserializer)?;
Ok(Utc::now() + Duration::seconds(seconds))
}
}