use crate::{
guild::invite::TargetType,
id::{
marker::{ChannelMarker, GuildMarker, UserMarker},
Id,
},
user::{self, DiscriminatorDisplay, User},
util::{ImageHash, Timestamp},
};
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
pub struct InviteCreate {
pub channel_id: Id<ChannelMarker>,
pub code: String,
pub created_at: Timestamp,
pub guild_id: Id<GuildMarker>,
#[serde(skip_serializing_if = "Option::is_none")]
pub inviter: Option<User>,
pub max_age: u64,
pub max_uses: u64,
#[serde(skip_serializing_if = "Option::is_none")]
pub target_user_type: Option<TargetType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub target_user: Option<PartialUser>,
pub temporary: bool,
pub uses: u8,
}
#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
pub struct PartialUser {
pub avatar: Option<ImageHash>,
#[serde(with = "user::discriminator")]
pub discriminator: u16,
pub id: Id<UserMarker>,
pub username: String,
}
impl PartialUser {
pub const fn discriminator(&self) -> DiscriminatorDisplay {
DiscriminatorDisplay::new(self.discriminator)
}
}
#[cfg(test)]
mod tests {
use super::{InviteCreate, PartialUser};
use crate::{id::Id, test::image_hash, util::Timestamp};
use serde::{Deserialize, Serialize};
use serde_test::Token;
use static_assertions::{assert_fields, assert_impl_all};
use std::{fmt::Debug, hash::Hash};
assert_fields!(
InviteCreate: channel_id,
code,
created_at,
guild_id,
inviter,
max_age,
max_uses,
target_user_type,
target_user,
temporary,
uses
);
assert_fields!(PartialUser: avatar, discriminator, id, username);
assert_impl_all!(
InviteCreate: Clone,
Debug,
Deserialize<'static>,
Eq,
Hash,
PartialEq,
Send,
Serialize,
Sync
);
assert_impl_all!(
PartialUser: Clone,
Debug,
Deserialize<'static>,
Eq,
Hash,
PartialEq,
Send,
Serialize,
Sync
);
#[test]
fn invite_create() {
let created_at = Timestamp::from_secs(1_609_459_200).expect("non zero");
let value = InviteCreate {
channel_id: Id::new(1),
code: "a".repeat(7),
created_at,
guild_id: Id::new(2),
inviter: None,
max_age: 3600,
max_uses: 5,
target_user_type: None,
target_user: None,
temporary: false,
uses: 0,
};
serde_test::assert_tokens(
&value,
&[
Token::Struct {
name: "InviteCreate",
len: 8,
},
Token::Str("channel_id"),
Token::NewtypeStruct { name: "Id" },
Token::Str("1"),
Token::Str("code"),
Token::Str("aaaaaaa"),
Token::Str("created_at"),
Token::Str("2021-01-01T00:00:00.000000+00:00"),
Token::Str("guild_id"),
Token::NewtypeStruct { name: "Id" },
Token::Str("2"),
Token::Str("max_age"),
Token::U64(3600),
Token::Str("max_uses"),
Token::U64(5),
Token::Str("temporary"),
Token::Bool(false),
Token::Str("uses"),
Token::U8(0),
Token::StructEnd,
],
);
}
#[test]
fn partial_user() {
let value = PartialUser {
avatar: Some(image_hash::AVATAR),
discriminator: 123,
id: Id::new(1),
username: "twilight".to_owned(),
};
serde_test::assert_tokens(
&value,
&[
Token::Struct {
name: "PartialUser",
len: 4,
},
Token::Str("avatar"),
Token::Some,
Token::Str(image_hash::AVATAR_INPUT),
Token::Str("discriminator"),
Token::Str("0123"),
Token::Str("id"),
Token::NewtypeStruct { name: "Id" },
Token::Str("1"),
Token::Str("username"),
Token::Str("twilight"),
Token::StructEnd,
],
);
}
}