Compare commits
11 Commits
013687c810
...
98f42aa03b
Author | SHA1 | Date |
---|---|---|
bitfl0wer | 98f42aa03b | |
bitfl0wer | 9cc7ede763 | |
bitfl0wer | a2b6d4e407 | |
bitfl0wer | 41a0e2fe27 | |
bitfl0wer | 00c70501c4 | |
bitfl0wer | 97ab757633 | |
bitfl0wer | 7434690027 | |
bitfl0wer | 577a399a7b | |
bitfl0wer | 11df180446 | |
bitfl0wer | 0923de59a4 | |
bitfl0wer | 8846159ffd |
|
@ -36,7 +36,7 @@ impl Message {
|
|||
chorus_request.deserialize_response::<Message>(user).await
|
||||
} else {
|
||||
for (index, attachment) in message.attachments.iter_mut().enumerate() {
|
||||
attachment.get_mut(index).unwrap().set_id(index as i16);
|
||||
attachment.get_mut(index).unwrap().id = Some(index as i16);
|
||||
}
|
||||
let mut form = reqwest::multipart::Form::new();
|
||||
let payload_json = to_string(&message).unwrap();
|
||||
|
@ -45,8 +45,8 @@ impl Message {
|
|||
form = form.part("payload_json", payload_field);
|
||||
|
||||
for (index, attachment) in message.attachments.unwrap().into_iter().enumerate() {
|
||||
let (attachment_content, current_attachment) = attachment.move_content();
|
||||
let (attachment_filename, _) = current_attachment.move_filename();
|
||||
let attachment_content = attachment.content;
|
||||
let attachment_filename = attachment.filename;
|
||||
let part_name = format!("files[{}]", index);
|
||||
let content_disposition = format!(
|
||||
"form-data; name=\"{}\"'; filename=\"{}\"",
|
||||
|
|
|
@ -9,7 +9,7 @@ use reqwest::Client;
|
|||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::errors::ChorusResult;
|
||||
use crate::gateway::{Gateway, GatewayHandle};
|
||||
use crate::gateway::{Gateway, GatewayHandle, Shared};
|
||||
use crate::ratelimiter::ChorusRequest;
|
||||
use crate::types::types::subconfigs::limits::rates::RateLimits;
|
||||
use crate::types::{
|
||||
|
@ -37,8 +37,6 @@ impl PartialEq for Instance {
|
|||
}
|
||||
}
|
||||
|
||||
impl Eq for Instance {}
|
||||
|
||||
impl std::hash::Hash for Instance {
|
||||
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
|
||||
self.urls.hash(state);
|
||||
|
@ -155,11 +153,11 @@ impl fmt::Display for Token {
|
|||
/// It is used for most authenticated actions on a Spacebar server.
|
||||
/// It also has its own [Gateway] connection.
|
||||
pub struct ChorusUser {
|
||||
pub belongs_to: Arc<RwLock<Instance>>,
|
||||
pub belongs_to: Shared<Instance>,
|
||||
pub token: String,
|
||||
pub limits: Option<HashMap<LimitType, Limit>>,
|
||||
pub settings: Arc<RwLock<UserSettings>>,
|
||||
pub object: Arc<RwLock<User>>,
|
||||
pub settings: Shared<UserSettings>,
|
||||
pub object: Shared<User>,
|
||||
pub gateway: GatewayHandle,
|
||||
}
|
||||
|
||||
|
@ -171,8 +169,6 @@ impl PartialEq for ChorusUser {
|
|||
}
|
||||
}
|
||||
|
||||
impl Eq for ChorusUser {}
|
||||
|
||||
impl ChorusUser {
|
||||
pub fn token(&self) -> String {
|
||||
self.token.clone()
|
||||
|
@ -188,11 +184,11 @@ impl ChorusUser {
|
|||
/// This isn't the prefered way to create a ChorusUser.
|
||||
/// See [Instance::login_account] and [Instance::register_account] instead.
|
||||
pub fn new(
|
||||
belongs_to: Arc<RwLock<Instance>>,
|
||||
belongs_to: Shared<Instance>,
|
||||
token: String,
|
||||
limits: Option<HashMap<LimitType, Limit>>,
|
||||
settings: Arc<RwLock<UserSettings>>,
|
||||
object: Arc<RwLock<User>>,
|
||||
settings: Shared<UserSettings>,
|
||||
object: Shared<User>,
|
||||
gateway: GatewayHandle,
|
||||
) -> ChorusUser {
|
||||
ChorusUser {
|
||||
|
@ -210,7 +206,7 @@ impl ChorusUser {
|
|||
/// registering or logging in to the Instance, where you do not yet have a User object, but still
|
||||
/// need to make a RateLimited request. To use the [`GatewayHandle`], you will have to identify
|
||||
/// first.
|
||||
pub(crate) async fn shell(instance: Arc<RwLock<Instance>>, token: String) -> ChorusUser {
|
||||
pub(crate) async fn shell(instance: Shared<Instance>, token: String) -> ChorusUser {
|
||||
let settings = Arc::new(RwLock::new(UserSettings::default()));
|
||||
let object = Arc::new(RwLock::new(User::default()));
|
||||
let wss_url = instance.read().unwrap().urls.wss.clone();
|
||||
|
|
|
@ -1,10 +1,9 @@
|
|||
use std::sync::{Arc, RwLock};
|
||||
|
||||
use bitflags::bitflags;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::Value;
|
||||
use serde_repr::{Deserialize_repr, Serialize_repr};
|
||||
|
||||
use crate::gateway::Shared;
|
||||
use crate::types::utils::Snowflake;
|
||||
use crate::types::{Team, User};
|
||||
|
||||
|
@ -27,7 +26,7 @@ pub struct Application {
|
|||
pub bot_require_code_grant: bool,
|
||||
pub verify_key: String,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
pub owner: Arc<RwLock<User>>,
|
||||
pub owner: Shared<User>,
|
||||
pub flags: u64,
|
||||
#[cfg(feature = "sqlx")]
|
||||
pub redirect_uris: Option<sqlx::types::Json<Vec<String>>>,
|
||||
|
@ -49,7 +48,7 @@ pub struct Application {
|
|||
#[cfg(feature = "sqlx")]
|
||||
pub install_params: Option<sqlx::types::Json<InstallParams>>,
|
||||
#[cfg(not(feature = "sqlx"))]
|
||||
pub install_params: Option<Arc<RwLock<InstallParams>>>,
|
||||
pub install_params: Option<Shared<InstallParams>>,
|
||||
pub terms_of_service_url: Option<String>,
|
||||
pub privacy_policy_url: Option<String>,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
|
@ -142,7 +141,7 @@ pub struct ApplicationCommand {
|
|||
pub application_id: Snowflake,
|
||||
pub name: String,
|
||||
pub description: String,
|
||||
pub options: Vec<Arc<RwLock<ApplicationCommandOption>>>,
|
||||
pub options: Vec<Shared<ApplicationCommandOption>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
|
@ -154,7 +153,7 @@ pub struct ApplicationCommandOption {
|
|||
pub description: String,
|
||||
pub required: bool,
|
||||
pub choices: Vec<ApplicationCommandOptionChoice>,
|
||||
pub options: Arc<RwLock<Vec<ApplicationCommandOption>>>,
|
||||
pub options: Shared<Vec<ApplicationCommandOption>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
||||
|
@ -190,14 +189,14 @@ pub enum ApplicationCommandOptionType {
|
|||
pub struct ApplicationCommandInteractionData {
|
||||
pub id: Snowflake,
|
||||
pub name: String,
|
||||
pub options: Vec<Arc<RwLock<ApplicationCommandInteractionDataOption>>>,
|
||||
pub options: Vec<Shared<ApplicationCommandInteractionDataOption>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct ApplicationCommandInteractionDataOption {
|
||||
pub name: String,
|
||||
pub value: Value,
|
||||
pub options: Vec<Arc<RwLock<ApplicationCommandInteractionDataOption>>>,
|
||||
pub options: Vec<Shared<ApplicationCommandInteractionDataOption>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
|
||||
|
@ -206,7 +205,7 @@ pub struct GuildApplicationCommandPermissions {
|
|||
pub id: Snowflake,
|
||||
pub application_id: Snowflake,
|
||||
pub guild_id: Snowflake,
|
||||
pub permissions: Vec<Arc<RwLock<ApplicationCommandPermission>>>,
|
||||
pub permissions: Vec<Shared<ApplicationCommandPermission>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
|
||||
|
|
|
@ -55,73 +55,3 @@ pub struct PartialDiscordFileAttachment {
|
|||
#[serde(skip_serializing)]
|
||||
pub content: Vec<u8>,
|
||||
}
|
||||
|
||||
impl PartialDiscordFileAttachment {
|
||||
/// Moves `self.content` out of `self` and returns it.
|
||||
pub fn move_content(self) -> (Vec<u8>, PartialDiscordFileAttachment) {
|
||||
let content = self.content;
|
||||
let updated_struct = PartialDiscordFileAttachment {
|
||||
id: self.id,
|
||||
filename: self.filename,
|
||||
description: self.description,
|
||||
content_type: self.content_type,
|
||||
size: self.size,
|
||||
url: self.url,
|
||||
proxy_url: self.proxy_url,
|
||||
height: self.height,
|
||||
width: self.width,
|
||||
ephemeral: self.ephemeral,
|
||||
duration_secs: self.duration_secs,
|
||||
waveform: self.waveform,
|
||||
content: Vec::new(),
|
||||
};
|
||||
(content, updated_struct)
|
||||
}
|
||||
|
||||
/// Moves `self.filename` out of `self` and returns it.
|
||||
pub fn move_filename(self) -> (String, PartialDiscordFileAttachment) {
|
||||
let filename = self.filename;
|
||||
let updated_struct = PartialDiscordFileAttachment {
|
||||
id: self.id,
|
||||
filename: String::new(),
|
||||
description: self.description,
|
||||
content_type: self.content_type,
|
||||
size: self.size,
|
||||
url: self.url,
|
||||
proxy_url: self.proxy_url,
|
||||
height: self.height,
|
||||
width: self.width,
|
||||
|
||||
ephemeral: self.ephemeral,
|
||||
duration_secs: self.duration_secs,
|
||||
waveform: self.waveform,
|
||||
content: self.content,
|
||||
};
|
||||
(filename, updated_struct)
|
||||
}
|
||||
|
||||
/// Moves `self.content_type` out of `self` and returns it.
|
||||
pub fn move_content_type(self) -> (Option<String>, PartialDiscordFileAttachment) {
|
||||
let content_type = self.content_type;
|
||||
let updated_struct = PartialDiscordFileAttachment {
|
||||
id: self.id,
|
||||
filename: self.filename,
|
||||
description: self.description,
|
||||
content_type: None,
|
||||
size: self.size,
|
||||
url: self.url,
|
||||
proxy_url: self.proxy_url,
|
||||
height: self.height,
|
||||
width: self.width,
|
||||
ephemeral: self.ephemeral,
|
||||
duration_secs: self.duration_secs,
|
||||
waveform: self.waveform,
|
||||
content: self.content,
|
||||
};
|
||||
(content_type, updated_struct)
|
||||
}
|
||||
|
||||
pub fn set_id(&mut self, id: i16) {
|
||||
self.id = Some(id);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,14 +1,13 @@
|
|||
use std::sync::{Arc, RwLock};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::gateway::Shared;
|
||||
use crate::types::utils::Snowflake;
|
||||
|
||||
#[derive(Serialize, Deserialize, Debug, Default, Clone)]
|
||||
/// See <https://discord.com/developers/docs/resources/audit-log#audit-log-entry-object>
|
||||
pub struct AuditLogEntry {
|
||||
pub target_id: Option<String>,
|
||||
pub changes: Option<Vec<Arc<RwLock<AuditLogChange>>>>,
|
||||
pub changes: Option<Vec<Shared<AuditLogChange>>>,
|
||||
pub user_id: Option<Snowflake>,
|
||||
pub id: Snowflake,
|
||||
// to:do implement an enum for these types
|
||||
|
|
|
@ -1,5 +1,4 @@
|
|||
use std::sync::{Arc, RwLock};
|
||||
|
||||
use crate::gateway::Shared;
|
||||
#[cfg(feature = "client")]
|
||||
use crate::gateway::Updateable;
|
||||
|
||||
|
@ -21,8 +20,8 @@ pub struct AutoModerationRule {
|
|||
pub creator_id: Snowflake,
|
||||
pub event_type: AutoModerationRuleEventType,
|
||||
pub trigger_type: AutoModerationRuleTriggerType,
|
||||
pub trigger_metadata: Arc<RwLock<AutoModerationRuleTriggerMetadata>>,
|
||||
pub actions: Vec<Arc<RwLock<AutoModerationAction>>>,
|
||||
pub trigger_metadata: Shared<AutoModerationRuleTriggerMetadata>,
|
||||
pub actions: Vec<Shared<AutoModerationAction>>,
|
||||
pub enabled: bool,
|
||||
pub exempt_roles: Vec<Snowflake>,
|
||||
pub exempt_channels: Vec<Snowflake>,
|
||||
|
@ -99,7 +98,7 @@ pub enum AutoModerationRuleKeywordPresetType {
|
|||
pub struct AutoModerationAction {
|
||||
#[serde(rename = "type")]
|
||||
pub action_type: AutoModerationActionType,
|
||||
pub metadata: Option<Arc<RwLock<AutoModerationActionMetadata>>>,
|
||||
pub metadata: Option<Shared<AutoModerationActionMetadata>>,
|
||||
}
|
||||
|
||||
#[derive(Serialize_repr, Deserialize_repr, Debug, Clone, Default)]
|
||||
|
|
|
@ -1,11 +1,10 @@
|
|||
use std::sync::{Arc, RwLock};
|
||||
|
||||
use chrono::{DateTime, Utc};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_aux::prelude::deserialize_string_from_number;
|
||||
use serde_repr::{Deserialize_repr, Serialize_repr};
|
||||
use std::fmt::Debug;
|
||||
|
||||
use crate::gateway::Shared;
|
||||
use crate::types::{
|
||||
entities::{GuildMember, User},
|
||||
utils::Snowflake,
|
||||
|
@ -71,13 +70,13 @@ pub struct Channel {
|
|||
pub permission_overwrites: Option<sqlx::types::Json<Vec<PermissionOverwrite>>>,
|
||||
#[cfg(not(feature = "sqlx"))]
|
||||
#[cfg_attr(feature = "client", observe_option_vec)]
|
||||
pub permission_overwrites: Option<Vec<Arc<RwLock<PermissionOverwrite>>>>,
|
||||
pub permission_overwrites: Option<Vec<Shared<PermissionOverwrite>>>,
|
||||
pub permissions: Option<String>,
|
||||
pub position: Option<i32>,
|
||||
pub rate_limit_per_user: Option<i32>,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
#[cfg_attr(feature = "client", observe_option_vec)]
|
||||
pub recipients: Option<Vec<Arc<RwLock<User>>>>,
|
||||
pub recipients: Option<Vec<Shared<User>>>,
|
||||
pub rtc_region: Option<String>,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
pub thread_metadata: Option<ThreadMetadata>,
|
||||
|
@ -171,7 +170,7 @@ pub struct ThreadMember {
|
|||
pub user_id: Option<Snowflake>,
|
||||
pub join_timestamp: Option<String>,
|
||||
pub flags: Option<u64>,
|
||||
pub member: Option<Arc<RwLock<GuildMember>>>,
|
||||
pub member: Option<Shared<GuildMember>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
use std::fmt::Debug;
|
||||
use std::sync::{Arc, RwLock};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::gateway::Shared;
|
||||
use crate::types::entities::User;
|
||||
use crate::types::Snowflake;
|
||||
|
||||
|
@ -31,7 +31,7 @@ pub struct Emoji {
|
|||
#[cfg(not(feature = "sqlx"))]
|
||||
pub roles: Option<Vec<Snowflake>>,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
pub user: Option<Arc<RwLock<User>>>,
|
||||
pub user: Option<Shared<User>>,
|
||||
pub require_colons: Option<bool>,
|
||||
pub managed: Option<bool>,
|
||||
pub animated: Option<bool>,
|
||||
|
|
|
@ -1,11 +1,11 @@
|
|||
use std::fmt::Debug;
|
||||
use std::sync::{Arc, RwLock};
|
||||
|
||||
use bitflags::bitflags;
|
||||
use chrono::{DateTime, Utc};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_repr::{Deserialize_repr, Serialize_repr};
|
||||
|
||||
use crate::gateway::Shared;
|
||||
use crate::types::types::guild_configuration::GuildFeaturesList;
|
||||
use crate::types::{
|
||||
entities::{Channel, Emoji, RoleObject, Sticker, User, VoiceState, Webhook},
|
||||
|
@ -45,14 +45,14 @@ pub struct Guild {
|
|||
pub bans: Option<Vec<GuildBan>>,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
#[cfg_attr(feature = "client", observe_option_vec)]
|
||||
pub channels: Option<Vec<Arc<RwLock<Channel>>>>,
|
||||
pub channels: Option<Vec<Shared<Channel>>>,
|
||||
pub default_message_notifications: Option<MessageNotificationLevel>,
|
||||
pub description: Option<String>,
|
||||
pub discovery_splash: Option<String>,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
#[cfg_attr(feature = "client", observe_vec)]
|
||||
#[serde(default)]
|
||||
pub emojis: Vec<Arc<RwLock<Emoji>>>,
|
||||
pub emojis: Vec<Shared<Emoji>>,
|
||||
pub explicit_content_filter: Option<i32>,
|
||||
//#[cfg_attr(feature = "sqlx", sqlx(try_from = "String"))]
|
||||
pub features: Option<GuildFeaturesList>,
|
||||
|
@ -88,7 +88,7 @@ pub struct Guild {
|
|||
pub region: Option<String>,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
#[cfg_attr(feature = "client", observe_option_vec)]
|
||||
pub roles: Option<Vec<Arc<RwLock<RoleObject>>>>,
|
||||
pub roles: Option<Vec<Shared<RoleObject>>>,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
pub rules_channel: Option<String>,
|
||||
pub rules_channel_id: Option<Snowflake>,
|
||||
|
@ -102,10 +102,10 @@ pub struct Guild {
|
|||
pub verification_level: Option<VerificationLevel>,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
#[cfg_attr(feature = "client", observe_option_vec)]
|
||||
pub voice_states: Option<Vec<Arc<RwLock<VoiceState>>>>,
|
||||
pub voice_states: Option<Vec<Shared<VoiceState>>>,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
#[cfg_attr(feature = "client", observe_option_vec)]
|
||||
pub webhooks: Option<Vec<Arc<RwLock<Webhook>>>>,
|
||||
pub webhooks: Option<Vec<Shared<Webhook>>>,
|
||||
#[cfg(feature = "sqlx")]
|
||||
pub welcome_screen: Option<sqlx::types::Json<WelcomeScreenObject>>,
|
||||
#[cfg(not(feature = "sqlx"))]
|
||||
|
@ -217,8 +217,6 @@ impl std::cmp::PartialEq for Guild {
|
|||
}
|
||||
}
|
||||
|
||||
impl std::cmp::Eq for Guild {}
|
||||
|
||||
/// See <https://docs.spacebar.chat/routes/#get-/guilds/-guild_id-/bans/-user->
|
||||
#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq, Eq, Hash)]
|
||||
#[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
|
||||
|
@ -239,11 +237,11 @@ pub struct GuildInvite {
|
|||
pub created_at: DateTime<Utc>,
|
||||
pub expires_at: Option<DateTime<Utc>>,
|
||||
pub guild_id: Snowflake,
|
||||
pub guild: Option<Arc<RwLock<Guild>>>,
|
||||
pub guild: Option<Shared<Guild>>,
|
||||
pub channel_id: Snowflake,
|
||||
pub channel: Option<Arc<RwLock<Channel>>>,
|
||||
pub channel: Option<Shared<Channel>>,
|
||||
pub inviter_id: Option<Snowflake>,
|
||||
pub inviter: Option<Arc<RwLock<User>>>,
|
||||
pub inviter: Option<Shared<User>>,
|
||||
pub target_user_id: Option<Snowflake>,
|
||||
pub target_user: Option<String>,
|
||||
pub target_user_type: Option<i32>,
|
||||
|
@ -296,7 +294,7 @@ pub struct GuildScheduledEvent {
|
|||
pub entity_type: GuildScheduledEventEntityType,
|
||||
pub entity_id: Option<Snowflake>,
|
||||
pub entity_metadata: Option<GuildScheduledEventEntityMetadata>,
|
||||
pub creator: Option<Arc<RwLock<User>>>,
|
||||
pub creator: Option<Shared<User>>,
|
||||
pub user_count: Option<u64>,
|
||||
pub image: Option<String>,
|
||||
}
|
||||
|
|
|
@ -1,7 +1,6 @@
|
|||
use std::sync::{Arc, RwLock};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::gateway::Shared;
|
||||
use crate::types::{entities::PublicUser, Snowflake};
|
||||
|
||||
#[derive(Debug, Deserialize, Default, Serialize, Clone)]
|
||||
|
@ -10,7 +9,7 @@ use crate::types::{entities::PublicUser, Snowflake};
|
|||
/// # Reference
|
||||
/// See <https://discord-userdoccers.vercel.app/resources/guild#guild-member-object>
|
||||
pub struct GuildMember {
|
||||
pub user: Option<Arc<RwLock<PublicUser>>>,
|
||||
pub user: Option<Shared<PublicUser>>,
|
||||
pub nick: Option<String>,
|
||||
pub avatar: Option<String>,
|
||||
pub roles: Vec<Snowflake>,
|
||||
|
|
|
@ -1,8 +1,7 @@
|
|||
use std::sync::{Arc, RwLock};
|
||||
|
||||
use chrono::{DateTime, Utc};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::gateway::Shared;
|
||||
use crate::types::{
|
||||
entities::{Application, User},
|
||||
utils::Snowflake,
|
||||
|
@ -23,14 +22,14 @@ pub struct Integration {
|
|||
pub expire_behaviour: Option<u8>,
|
||||
pub expire_grace_period: Option<u16>,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
pub user: Option<Arc<RwLock<User>>>,
|
||||
pub user: Option<Shared<User>>,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
pub account: IntegrationAccount,
|
||||
pub synced_at: Option<DateTime<Utc>>,
|
||||
pub subscriber_count: Option<f64>,
|
||||
pub revoked: Option<bool>,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
pub application: Option<Arc<RwLock<Application>>>,
|
||||
pub application: Option<Shared<Application>>,
|
||||
pub scopes: Option<Vec<String>>,
|
||||
}
|
||||
|
||||
|
|
|
@ -1,8 +1,7 @@
|
|||
use std::sync::{Arc, RwLock};
|
||||
|
||||
use chrono::{DateTime, Utc};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::gateway::Shared;
|
||||
use crate::types::{Snowflake, WelcomeScreenObject};
|
||||
|
||||
use super::guild::GuildScheduledEvent;
|
||||
|
@ -21,7 +20,7 @@ pub struct Invite {
|
|||
pub flags: Option<i32>,
|
||||
pub guild: Option<InviteGuild>,
|
||||
pub guild_id: Option<Snowflake>,
|
||||
pub guild_scheduled_event: Option<Arc<RwLock<GuildScheduledEvent>>>,
|
||||
pub guild_scheduled_event: Option<Shared<GuildScheduledEvent>>,
|
||||
#[serde(rename = "type")]
|
||||
pub invite_type: Option<i32>,
|
||||
pub inviter: Option<User>,
|
||||
|
@ -59,7 +58,7 @@ pub struct InviteGuild {
|
|||
/// See <https://discord-userdoccers.vercel.app/resources/invite#invite-stage-instance-object>
|
||||
#[derive(Debug, Serialize, Deserialize)]
|
||||
pub struct InviteStageInstance {
|
||||
pub members: Vec<Arc<RwLock<GuildMember>>>,
|
||||
pub members: Vec<Shared<GuildMember>>,
|
||||
pub participant_count: i32,
|
||||
pub speaker_count: i32,
|
||||
pub topic: String,
|
||||
|
|
|
@ -1,7 +1,6 @@
|
|||
use std::sync::{Arc, RwLock};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::gateway::Shared;
|
||||
use crate::types::{
|
||||
entities::{
|
||||
Application, Attachment, Channel, Emoji, GuildMember, PublicUser, RoleSubscriptionData,
|
||||
|
@ -121,7 +120,7 @@ pub struct MessageInteraction {
|
|||
pub interaction_type: u8,
|
||||
pub name: String,
|
||||
pub user: User,
|
||||
pub member: Option<Arc<RwLock<GuildMember>>>,
|
||||
pub member: Option<Shared<GuildMember>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Default, PartialEq, Clone, Serialize, Deserialize, Eq, PartialOrd, Ord)]
|
||||
|
|
|
@ -24,7 +24,6 @@ pub use voice_state::*;
|
|||
pub use webhook::*;
|
||||
|
||||
use crate::gateway::Shared;
|
||||
|
||||
#[cfg(feature = "client")]
|
||||
use crate::gateway::Updateable;
|
||||
|
||||
|
@ -36,7 +35,6 @@ use async_trait::async_trait;
|
|||
|
||||
#[cfg(feature = "client")]
|
||||
use std::fmt::Debug;
|
||||
|
||||
#[cfg(feature = "client")]
|
||||
use std::sync::{Arc, RwLock};
|
||||
|
||||
|
|
|
@ -1,9 +1,8 @@
|
|||
use std::sync::{Arc, RwLock};
|
||||
|
||||
use chrono::{DateTime, Utc};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_repr::{Deserialize_repr, Serialize_repr};
|
||||
|
||||
use crate::gateway::Shared;
|
||||
use crate::types::Snowflake;
|
||||
|
||||
use super::PublicUser;
|
||||
|
@ -15,7 +14,7 @@ pub struct Relationship {
|
|||
#[serde(rename = "type")]
|
||||
pub relationship_type: RelationshipType,
|
||||
pub nickname: Option<String>,
|
||||
pub user: Arc<RwLock<PublicUser>>,
|
||||
pub user: Shared<PublicUser>,
|
||||
pub since: Option<DateTime<Utc>>,
|
||||
}
|
||||
|
||||
|
|
|
@ -1,7 +1,6 @@
|
|||
use std::sync::{Arc, RwLock};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::gateway::Shared;
|
||||
use crate::types::{entities::User, utils::Snowflake};
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize, Clone, Default)]
|
||||
|
@ -24,7 +23,7 @@ pub struct Sticker {
|
|||
pub available: Option<bool>,
|
||||
pub guild_id: Option<Snowflake>,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
pub user: Option<Arc<RwLock<User>>>,
|
||||
pub user: Option<Shared<User>>,
|
||||
pub sort_value: Option<u8>,
|
||||
}
|
||||
|
||||
|
|
|
@ -1,7 +1,6 @@
|
|||
use std::sync::{Arc, RwLock};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::gateway::Shared;
|
||||
use crate::types::entities::User;
|
||||
use crate::types::Snowflake;
|
||||
|
||||
|
@ -21,5 +20,5 @@ pub struct TeamMember {
|
|||
pub membership_state: u8,
|
||||
pub permissions: Vec<String>,
|
||||
pub team_id: Snowflake,
|
||||
pub user: Arc<RwLock<User>>,
|
||||
pub user: Shared<User>,
|
||||
}
|
||||
|
|
|
@ -1,8 +1,7 @@
|
|||
use std::sync::{Arc, RwLock};
|
||||
|
||||
use chrono::{DateTime, Utc};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::gateway::Shared;
|
||||
use crate::types::{
|
||||
entities::{Guild, User},
|
||||
utils::Snowflake,
|
||||
|
@ -18,13 +17,13 @@ pub struct GuildTemplate {
|
|||
pub usage_count: Option<u64>,
|
||||
pub creator_id: Snowflake,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
pub creator: Arc<RwLock<User>>,
|
||||
pub creator: Shared<User>,
|
||||
pub created_at: DateTime<Utc>,
|
||||
pub updated_at: DateTime<Utc>,
|
||||
pub source_guild_id: Snowflake,
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
pub source_guild: Vec<Arc<RwLock<Guild>>>,
|
||||
pub source_guild: Vec<Shared<Guild>>,
|
||||
// Unsure how a {recursive: Guild} looks like, might be a Vec?
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
pub serialized_source_guild: Vec<Arc<RwLock<Guild>>>,
|
||||
pub serialized_source_guild: Vec<Shared<Guild>>,
|
||||
}
|
||||
|
|
|
@ -26,7 +26,7 @@ pub struct UserData {
|
|||
}
|
||||
|
||||
impl User {
|
||||
pub fn to_public_user(self) -> PublicUser {
|
||||
pub fn into_public_user(self) -> PublicUser {
|
||||
PublicUser::from(self)
|
||||
}
|
||||
}
|
||||
|
|
|
@ -3,6 +3,8 @@ use std::sync::{Arc, RwLock};
|
|||
use chrono::{serde::ts_milliseconds_option, Utc};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::gateway::Shared;
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
|
||||
#[cfg_attr(feature = "sqlx", derive(sqlx::Type))]
|
||||
#[serde(rename_all = "lowercase")]
|
||||
|
@ -77,7 +79,7 @@ pub struct UserSettings {
|
|||
#[cfg(not(feature = "sqlx"))]
|
||||
pub restricted_guilds: Vec<String>,
|
||||
pub show_current_game: bool,
|
||||
pub status: Arc<RwLock<UserStatus>>,
|
||||
pub status: Shared<UserStatus>,
|
||||
pub stream_notifications_enabled: bool,
|
||||
pub theme: UserTheme,
|
||||
pub timezone_offset: i16,
|
||||
|
@ -153,5 +155,5 @@ pub struct GuildFolder {
|
|||
#[derive(Debug, Serialize, Deserialize)]
|
||||
pub struct LoginResult {
|
||||
pub token: String,
|
||||
pub settings: Arc<RwLock<UserSettings>>,
|
||||
pub settings: Shared<UserSettings>,
|
||||
}
|
||||
|
|
|
@ -1,8 +1,7 @@
|
|||
use std::sync::{Arc, RwLock};
|
||||
|
||||
#[cfg(feature = "client")]
|
||||
use chorus_macros::Composite;
|
||||
|
||||
use crate::gateway::Shared;
|
||||
#[cfg(feature = "client")]
|
||||
use crate::types::Composite;
|
||||
|
||||
|
@ -33,7 +32,7 @@ pub struct VoiceState {
|
|||
pub guild: Option<Guild>,
|
||||
pub channel_id: Option<Snowflake>,
|
||||
pub user_id: Snowflake,
|
||||
pub member: Option<Arc<RwLock<GuildMember>>>,
|
||||
pub member: Option<Shared<GuildMember>>,
|
||||
pub session_id: String,
|
||||
pub token: Option<String>,
|
||||
pub deaf: bool,
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
use std::fmt::Debug;
|
||||
use std::sync::{Arc, RwLock};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::gateway::Shared;
|
||||
#[cfg(feature = "client")]
|
||||
use crate::gateway::Updateable;
|
||||
|
||||
|
@ -36,10 +36,10 @@ pub struct Webhook {
|
|||
pub application_id: Snowflake,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
pub user: Option<Arc<RwLock<User>>>,
|
||||
pub user: Option<Shared<User>>,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
#[cfg_attr(feature = "sqlx", sqlx(skip))]
|
||||
pub source_guild: Option<Arc<RwLock<Guild>>>,
|
||||
pub source_guild: Option<Shared<Guild>>,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub url: Option<String>,
|
||||
}
|
||||
|
|
|
@ -1,4 +1,5 @@
|
|||
use crate::types::events::WebSocketEvent;
|
||||
use crate::types::IntoShared;
|
||||
use crate::types::{entities::Channel, JsonField, Snowflake, SourceUrlField};
|
||||
use chorus_macros::{JsonField, SourceUrlField};
|
||||
use chrono::{DateTime, Utc};
|
||||
|
@ -8,7 +9,7 @@ use serde::{Deserialize, Serialize};
|
|||
use super::UpdateMessage;
|
||||
|
||||
#[cfg(feature = "client")]
|
||||
use std::sync::{Arc, RwLock};
|
||||
use crate::gateway::Shared;
|
||||
|
||||
#[cfg(feature = "client")]
|
||||
use crate::types::Guild;
|
||||
|
@ -42,9 +43,9 @@ impl UpdateMessage<Guild> for ChannelCreate {
|
|||
self.channel.guild_id
|
||||
}
|
||||
|
||||
fn update(&mut self, object_to_update: Arc<RwLock<Guild>>) {
|
||||
fn update(&mut self, object_to_update: Shared<Guild>) {
|
||||
let mut write = object_to_update.write().unwrap();
|
||||
let update = Arc::new(RwLock::new(self.channel.clone()));
|
||||
let update = self.channel.clone().into_shared();
|
||||
if write.channels.is_some() {
|
||||
write.channels.as_mut().unwrap().push(update);
|
||||
} else {
|
||||
|
@ -68,7 +69,7 @@ impl WebSocketEvent for ChannelUpdate {}
|
|||
|
||||
#[cfg(feature = "client")]
|
||||
impl UpdateMessage<Channel> for ChannelUpdate {
|
||||
fn update(&mut self, object_to_update: Arc<RwLock<Channel>>) {
|
||||
fn update(&mut self, object_to_update: Shared<Channel>) {
|
||||
let mut write = object_to_update.write().unwrap();
|
||||
*write = self.channel.clone();
|
||||
}
|
||||
|
@ -114,7 +115,7 @@ impl UpdateMessage<Guild> for ChannelDelete {
|
|||
self.channel.guild_id
|
||||
}
|
||||
|
||||
fn update(&mut self, object_to_update: Arc<RwLock<Guild>>) {
|
||||
fn update(&mut self, object_to_update: Shared<Guild>) {
|
||||
if self.id().is_none() {
|
||||
return;
|
||||
}
|
||||
|
|
|
@ -5,8 +5,8 @@ use serde::{Deserialize, Serialize};
|
|||
use crate::types::entities::{Guild, PublicUser, UnavailableGuild};
|
||||
use crate::types::events::WebSocketEvent;
|
||||
use crate::types::{
|
||||
AuditLogEntry, Emoji, GuildMember, GuildScheduledEvent, JsonField, RoleObject, Snowflake,
|
||||
SourceUrlField, Sticker,
|
||||
AuditLogEntry, Emoji, GuildMember, GuildScheduledEvent, IntoShared, JsonField, RoleObject,
|
||||
Snowflake, SourceUrlField, Sticker,
|
||||
};
|
||||
|
||||
use super::PresenceUpdate;
|
||||
|
@ -14,7 +14,7 @@ use super::PresenceUpdate;
|
|||
#[cfg(feature = "client")]
|
||||
use super::UpdateMessage;
|
||||
#[cfg(feature = "client")]
|
||||
use std::sync::{Arc, RwLock};
|
||||
use crate::gateway::Shared;
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize, Default, Clone, SourceUrlField, JsonField)]
|
||||
/// See <https://discord.com/developers/docs/topics/gateway-events#guild-create>;
|
||||
|
@ -38,7 +38,7 @@ impl UpdateMessage<Guild> for GuildCreate {
|
|||
}
|
||||
}
|
||||
|
||||
fn update(&mut self, _: Arc<RwLock<Guild>>) {}
|
||||
fn update(&mut self, _: Shared<Guild>) {}
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize, Clone)]
|
||||
|
@ -114,7 +114,7 @@ impl UpdateMessage<Guild> for GuildDelete {
|
|||
fn id(&self) -> Option<Snowflake> {
|
||||
Some(self.guild.id)
|
||||
}
|
||||
fn update(&mut self, _: Arc<RwLock<Guild>>) {}
|
||||
fn update(&mut self, _: Shared<Guild>) {}
|
||||
}
|
||||
|
||||
impl WebSocketEvent for GuildDelete {}
|
||||
|
@ -229,16 +229,16 @@ impl UpdateMessage<Guild> for GuildRoleCreate {
|
|||
Some(self.guild_id)
|
||||
}
|
||||
|
||||
fn update(&mut self, object_to_update: Arc<RwLock<Guild>>) {
|
||||
fn update(&mut self, object_to_update: Shared<Guild>) {
|
||||
let mut object_to_update = object_to_update.write().unwrap();
|
||||
if object_to_update.roles.is_some() {
|
||||
object_to_update
|
||||
.roles
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.push(Arc::new(RwLock::new(self.role.clone())));
|
||||
.push(self.role.clone().into_shared());
|
||||
} else {
|
||||
object_to_update.roles = Some(Vec::from([Arc::new(RwLock::new(self.role.clone()))]));
|
||||
object_to_update.roles = Some(Vec::from([self.role.clone().into_shared()]));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -262,7 +262,7 @@ impl UpdateMessage<RoleObject> for GuildRoleUpdate {
|
|||
Some(self.role.id)
|
||||
}
|
||||
|
||||
fn update(&mut self, object_to_update: Arc<RwLock<RoleObject>>) {
|
||||
fn update(&mut self, object_to_update: Shared<RoleObject>) {
|
||||
let mut write = object_to_update.write().unwrap();
|
||||
*write = self.role.clone();
|
||||
}
|
||||
|
|
|
@ -39,9 +39,9 @@ use serde_json::{from_str, from_value, to_value, Value};
|
|||
#[cfg(feature = "client")]
|
||||
use std::collections::HashMap;
|
||||
|
||||
use std::fmt::Debug;
|
||||
#[cfg(feature = "client")]
|
||||
use std::sync::{Arc, RwLock};
|
||||
use crate::gateway::Shared;
|
||||
use std::fmt::Debug;
|
||||
|
||||
#[cfg(feature = "client")]
|
||||
use serde::de::DeserializeOwned;
|
||||
|
@ -132,7 +132,7 @@ pub(crate) trait UpdateMessage<T>: Clone + JsonField + SourceUrlField
|
|||
where
|
||||
T: Updateable + Serialize + DeserializeOwned + Clone,
|
||||
{
|
||||
fn update(&mut self, object_to_update: Arc<RwLock<T>>) {
|
||||
fn update(&mut self, object_to_update: Shared<T>) {
|
||||
update_object(self.get_json(), object_to_update)
|
||||
}
|
||||
fn id(&self) -> Option<Snowflake>;
|
||||
|
@ -152,7 +152,7 @@ pub trait SourceUrlField: Clone {
|
|||
/// Only applicable for events where the Update struct is the same as the Entity struct
|
||||
pub(crate) fn update_object(
|
||||
value: String,
|
||||
object: Arc<RwLock<(impl Updateable + Serialize + DeserializeOwned + Clone)>>,
|
||||
object: Shared<(impl Updateable + Serialize + DeserializeOwned + Clone)>,
|
||||
) {
|
||||
let data_from_event: HashMap<String, Value> = from_str(&value).unwrap();
|
||||
let mut original_data: HashMap<String, Value> =
|
||||
|
|
937
tests/types.rs
937
tests/types.rs
|
@ -33,8 +33,10 @@ mod config {
|
|||
|
||||
mod guild_configuration {
|
||||
use std::ops::Deref;
|
||||
use std::str::FromStr;
|
||||
|
||||
use chorus::types::types::guild_configuration::GuildFeaturesList;
|
||||
use chorus::types::types::guild_configuration::{GuildFeatures, GuildFeaturesList};
|
||||
use chorus::types::{Error, GuildError};
|
||||
|
||||
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
|
||||
#[cfg_attr(not(target_arch = "wasm32"), test)]
|
||||
|
@ -42,6 +44,835 @@ mod config {
|
|||
let guild_features_list = &GuildFeaturesList::default();
|
||||
let _guild_features_list_deref = guild_features_list.deref().clone();
|
||||
}
|
||||
|
||||
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
|
||||
#[cfg_attr(not(target_arch = "wasm32"), test)]
|
||||
fn test_deref_mut() {
|
||||
let mut guild_features_list = GuildFeaturesList::default();
|
||||
guild_features_list.clear();
|
||||
let mut list = GuildFeaturesList::default().to_vec();
|
||||
list.push(GuildFeatures::ActivitiesAlpha);
|
||||
*guild_features_list = list.to_vec();
|
||||
assert_eq!(guild_features_list.len(), 1);
|
||||
}
|
||||
|
||||
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
|
||||
#[cfg_attr(not(target_arch = "wasm32"), test)]
|
||||
fn test_display() {
|
||||
let mut guild_features_list = GuildFeaturesList::default();
|
||||
guild_features_list.push(GuildFeatures::ActivitiesAlpha);
|
||||
guild_features_list.push(GuildFeatures::AnimatedBanner);
|
||||
assert_eq!(
|
||||
format!("{}", guild_features_list),
|
||||
"ACTIVITIES_ALPHA,ANIMATED_BANNER"
|
||||
);
|
||||
}
|
||||
|
||||
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
|
||||
#[cfg_attr(not(target_arch = "wasm32"), test)]
|
||||
fn test_from_str() {
|
||||
// GPT moment
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("ACTIVITIES_ALPHA").unwrap(),
|
||||
GuildFeatures::ActivitiesAlpha
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("ACTIVITIES_EMPLOYEE").unwrap(),
|
||||
GuildFeatures::ActivitiesEmployee
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("ACTIVITIES_INTERNAL_DEV").unwrap(),
|
||||
GuildFeatures::ActivitiesInternalDev
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("ANIMATED_BANNER").unwrap(),
|
||||
GuildFeatures::AnimatedBanner
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("ANIMATED_ICON").unwrap(),
|
||||
GuildFeatures::AnimatedIcon
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("APPLICATION_COMMAND_PERMISSIONS_V2").unwrap(),
|
||||
GuildFeatures::ApplicationCommandPermissionsV2
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("AUTO_MODERATION").unwrap(),
|
||||
GuildFeatures::AutoModeration
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("AUTO_MOD_TRIGGER_KEYWORD_FILTER").unwrap(),
|
||||
GuildFeatures::AutoModTriggerKeywordFilter
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("AUTO_MOD_TRIGGER_ML_SPAM_FILTER").unwrap(),
|
||||
GuildFeatures::AutoModTriggerMLSpamFilter
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("AUTO_MOD_TRIGGER_SPAM_LINK_FILTER").unwrap(),
|
||||
GuildFeatures::AutoModTriggerSpamLinkFilter
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("AUTO_MOD_TRIGGER_USER_PROFILE").unwrap(),
|
||||
GuildFeatures::AutoModTriggerUserProfile
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("BANNER").unwrap(),
|
||||
GuildFeatures::Banner
|
||||
);
|
||||
assert_eq!(GuildFeatures::from_str("BFG").unwrap(), GuildFeatures::Bfg);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("BOOSTING_TIERS_EXPERIMENT_MEDIUM_GUILD").unwrap(),
|
||||
GuildFeatures::BoostingTiersExperimentMediumGuild
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("BOOSTING_TIERS_EXPERIMENT_SMALL_GUILD").unwrap(),
|
||||
GuildFeatures::BoostingTiersExperimentSmallGuild
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("BOT_DEVELOPER_EARLY_ACCESS").unwrap(),
|
||||
GuildFeatures::BotDeveloperEarlyAccess
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("BURST_REACTIONS").unwrap(),
|
||||
GuildFeatures::BurstReactions
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("COMMUNITY_CANARY").unwrap(),
|
||||
GuildFeatures::CommunityCanary
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("COMMUNITY_EXP_LARGE_GATED").unwrap(),
|
||||
GuildFeatures::CommunityExpLargeGated
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("COMMUNITY_EXP_LARGE_UNGATED").unwrap(),
|
||||
GuildFeatures::CommunityExpLargeUngated
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("COMMUNITY_EXP_MEDIUM").unwrap(),
|
||||
GuildFeatures::CommunityExpMedium
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("CHANNEL_EMOJIS_GENERATED").unwrap(),
|
||||
GuildFeatures::ChannelEmojisGenerated
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("CHANNEL_HIGHLIGHTS").unwrap(),
|
||||
GuildFeatures::ChannelHighlights
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("CHANNEL_HIGHLIGHTS_DISABLED").unwrap(),
|
||||
GuildFeatures::ChannelHighlightsDisabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("CLYDE_ENABLED").unwrap(),
|
||||
GuildFeatures::ClydeEnabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("CLYDE_EXPERIMENT_ENABLED").unwrap(),
|
||||
GuildFeatures::ClydeExperimentEnabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("CLYDE_DISABLED").unwrap(),
|
||||
GuildFeatures::ClydeDisabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("COMMUNITY").unwrap(),
|
||||
GuildFeatures::Community
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("CREATOR_ACCEPTED_NEW_TERMS").unwrap(),
|
||||
GuildFeatures::CreatorAcceptedNewTerms
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("CREATOR_MONETIZABLE").unwrap(),
|
||||
GuildFeatures::CreatorMonetizable
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("CREATOR_MONETIZABLE_DISABLED").unwrap(),
|
||||
GuildFeatures::CreatorMonetizableDisabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("CREATOR_MONETIZABLE_PENDING_NEW_OWNER_ONBOARDING")
|
||||
.unwrap(),
|
||||
GuildFeatures::CreatorMonetizablePendingNewOwnerOnboarding
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("CREATOR_MONETIZABLE_PROVISIONAL").unwrap(),
|
||||
GuildFeatures::CreatorMonetizableProvisional
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("CREATOR_MONETIZABLE_RESTRICTED").unwrap(),
|
||||
GuildFeatures::CreatorMonetizableRestricted
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("CREATOR_MONETIZABLE_WHITEGLOVE").unwrap(),
|
||||
GuildFeatures::CreatorMonetizableWhiteglove
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("CREATOR_MONETIZABLE_APPLICATION_ALLOWLIST").unwrap(),
|
||||
GuildFeatures::CreatorMonetizableApplicationAllowlist
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("CREATE_STORE_PAGE").unwrap(),
|
||||
GuildFeatures::CreateStorePage
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("DEVELOPER_SUPPORT_SERVER").unwrap(),
|
||||
GuildFeatures::DeveloperSupportServer
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("DISCOVERABLE_DISABLED").unwrap(),
|
||||
GuildFeatures::DiscoverableDisabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("DISCOVERABLE").unwrap(),
|
||||
GuildFeatures::Discoverable
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("ENABLED_DISCOVERABLE_BEFORE").unwrap(),
|
||||
GuildFeatures::EnabledDiscoverableBefore
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("EXPOSED_TO_ACTIVITIES_WTP_EXPERIMENT").unwrap(),
|
||||
GuildFeatures::ExposedToActivitiesWTPExperiment
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("GUESTS_ENABLED").unwrap(),
|
||||
GuildFeatures::GuestsEnabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("GUILD_AUTOMOD_DEFAULT_LIST").unwrap(),
|
||||
GuildFeatures::GuildAutomodDefaultList
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("GUILD_COMMUNICATION_DISABLED_GUILDS").unwrap(),
|
||||
GuildFeatures::GuildCommunicationDisabledGuilds
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("GUILD_HOME_DEPRECATION_OVERRIDE").unwrap(),
|
||||
GuildFeatures::GuildHomeDeprecationOverride
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("GUILD_HOME_OVERRIDE").unwrap(),
|
||||
GuildFeatures::GuildHomeOverride
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("GUILD_HOME_TEST").unwrap(),
|
||||
GuildFeatures::GuildHomeTest
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("GUILD_MEMBER_VERIFICATION_EXPERIMENT").unwrap(),
|
||||
GuildFeatures::GuildMemberVerificationExperiment
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("GUILD_ONBOARDING").unwrap(),
|
||||
GuildFeatures::GuildOnboarding
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("GUILD_ONBOARDING_ADMIN_ONLY").unwrap(),
|
||||
GuildFeatures::GuildOnboardingAdminOnly
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("GUILD_ONBOARDING_EVER_ENABLED").unwrap(),
|
||||
GuildFeatures::GuildOnboardingEverEnabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("GUILD_ONBOARDING_HAS_PROMPTS").unwrap(),
|
||||
GuildFeatures::GuildOnboardingHasPrompts
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("GUILD_ROLE_SUBSCRIPTION").unwrap(),
|
||||
GuildFeatures::GuildRoleSubscription
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("GUILD_ROLE_SUBSCRIPTION_PURCHASE_FEEDBACK_LOOP").unwrap(),
|
||||
GuildFeatures::GuildRoleSubscriptionPurchaseFeedbackLoop
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("GUILD_ROLE_SUBSCRIPTION_TRIALS").unwrap(),
|
||||
GuildFeatures::GuildRoleSubscriptionTrials
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("GUILD_SERVER_GUIDE").unwrap(),
|
||||
GuildFeatures::GuildServerGuide
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("GUILD_WEB_PAGE_VANITY_URL").unwrap(),
|
||||
GuildFeatures::GuildWebPageVanityURL
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("HAD_EARLY_ACTIVITIES_ACCESS").unwrap(),
|
||||
GuildFeatures::HadEarlyActivitiesAccess
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("HAS_DIRECTORY_ENTRY").unwrap(),
|
||||
GuildFeatures::HasDirectoryEntry
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("HIDE_FROM_EXPERIMENT_UI").unwrap(),
|
||||
GuildFeatures::HideFromExperimentUi
|
||||
);
|
||||
assert_eq!(GuildFeatures::from_str("HUB").unwrap(), GuildFeatures::Hub);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("INCREASED_THREAD_LIMIT").unwrap(),
|
||||
GuildFeatures::IncreasedThreadLimit
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("INTERNAL_EMPLOYEE_ONLY").unwrap(),
|
||||
GuildFeatures::InternalEmployeeOnly
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("INVITE_SPLASH").unwrap(),
|
||||
GuildFeatures::InviteSplash
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("INVITES_DISABLED").unwrap(),
|
||||
GuildFeatures::InvitesDisabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("LINKED_TO_HUB").unwrap(),
|
||||
GuildFeatures::LinkedToHub
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("MARKETPLACES_CONNECTION_ROLES").unwrap(),
|
||||
GuildFeatures::MarketplacesConnectionRoles
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("MEMBER_PROFILES").unwrap(),
|
||||
GuildFeatures::MemberProfiles
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("MEMBER_VERIFICATION_GATE_ENABLED").unwrap(),
|
||||
GuildFeatures::MemberVerificationGateEnabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("MEMBER_VERIFICATION_MANUAL_APPROVAL").unwrap(),
|
||||
GuildFeatures::MemberVerificationManualApproval
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("MOBILE_WEB_ROLE_SUBSCRIPTION_PURCHASE_PAGE").unwrap(),
|
||||
GuildFeatures::MobileWebRoleSubscriptionPurchasePage
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("MONETIZATION_ENABLED").unwrap(),
|
||||
GuildFeatures::MonetizationEnabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("MORE_EMOJI").unwrap(),
|
||||
GuildFeatures::MoreEmoji
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("MORE_STICKERS").unwrap(),
|
||||
GuildFeatures::MoreStickers
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("NEWS").unwrap(),
|
||||
GuildFeatures::News
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("NEW_THREAD_PERMISSIONS").unwrap(),
|
||||
GuildFeatures::NewThreadPermissions
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("PARTNERED").unwrap(),
|
||||
GuildFeatures::Partnered
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("PREMIUM_TIER_3_OVERRIDE").unwrap(),
|
||||
GuildFeatures::PremiumTier3Override
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("PREVIEW_ENABLED").unwrap(),
|
||||
GuildFeatures::PreviewEnabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("RAID_ALERTS_DISABLED").unwrap(),
|
||||
GuildFeatures::RaidAlertsDisabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("RELAY_ENABLED").unwrap(),
|
||||
GuildFeatures::RelayEnabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("RESTRICT_SPAM_RISK_GUILD").unwrap(),
|
||||
GuildFeatures::RestrictSpamRiskGuild
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("ROLE_ICONS").unwrap(),
|
||||
GuildFeatures::RoleIcons
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("ROLE_SUBSCRIPTIONS_AVAILABLE_FOR_PURCHASE").unwrap(),
|
||||
GuildFeatures::RoleSubscriptionsAvailableForPurchase
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("ROLE_SUBSCRIPTIONS_ENABLED").unwrap(),
|
||||
GuildFeatures::RoleSubscriptionsEnabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("ROLE_SUBSCRIPTIONS_ENABLED_FOR_PURCHASE").unwrap(),
|
||||
GuildFeatures::RoleSubscriptionsEnabledForPurchase
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("SHARD").unwrap(),
|
||||
GuildFeatures::Shard
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("SHARED_CANVAS_FRIENDS_AND_FAMILY_TEST").unwrap(),
|
||||
GuildFeatures::SharedCanvasFriendsAndFamilyTest
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("SOUNDBOARD").unwrap(),
|
||||
GuildFeatures::Soundboard
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("SUMMARIES_ENABLED").unwrap(),
|
||||
GuildFeatures::SummariesEnabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("SUMMARIES_ENABLED_GA").unwrap(),
|
||||
GuildFeatures::SummariesEnabledGa
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("SUMMARIES_DISABLED_BY_USER").unwrap(),
|
||||
GuildFeatures::SummariesDisabledByUser
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("SUMMARIES_ENABLED_BY_USER").unwrap(),
|
||||
GuildFeatures::SummariesEnabledByUser
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("TEXT_IN_STAGE_ENABLED").unwrap(),
|
||||
GuildFeatures::TextInStageEnabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("TEXT_IN_VOICE_ENABLED").unwrap(),
|
||||
GuildFeatures::TextInVoiceEnabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("THREADS_ENABLED_TESTING").unwrap(),
|
||||
GuildFeatures::ThreadsEnabledTesting
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("THREADS_ENABLED").unwrap(),
|
||||
GuildFeatures::ThreadsEnabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("THREAD_DEFAULT_AUTO_ARCHIVE_DURATION").unwrap(),
|
||||
GuildFeatures::ThreadDefaultAutoArchiveDuration
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("THREADS_ONLY_CHANNEL").unwrap(),
|
||||
GuildFeatures::ThreadsOnlyChannel
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("TICKETED_EVENTS_ENABLED").unwrap(),
|
||||
GuildFeatures::TicketedEventsEnabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("TICKETING_ENABLED").unwrap(),
|
||||
GuildFeatures::TicketingEnabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("VANITY_URL").unwrap(),
|
||||
GuildFeatures::VanityUrl
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("VERIFIED").unwrap(),
|
||||
GuildFeatures::Verified
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("VIP_REGIONS").unwrap(),
|
||||
GuildFeatures::VipRegions
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("VOICE_CHANNEL_EFFECTS").unwrap(),
|
||||
GuildFeatures::VoiceChannelEffects
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("WELCOME_SCREEN_ENABLED").unwrap(),
|
||||
GuildFeatures::WelcomeScreenEnabled
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("ALIASABLE_NAMES").unwrap(),
|
||||
GuildFeatures::AliasableNames
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("ALLOW_INVALID_CHANNEL_NAME").unwrap(),
|
||||
GuildFeatures::AllowInvalidChannelName
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("ALLOW_UNNAMED_CHANNELS").unwrap(),
|
||||
GuildFeatures::AllowUnnamedChannels
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("CROSS_CHANNEL_REPLIES").unwrap(),
|
||||
GuildFeatures::CrossChannelReplies
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("IRC_LIKE_CATEGORY_NAMES").unwrap(),
|
||||
GuildFeatures::IrcLikeCategoryNames
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("INVITES_CLOSED").unwrap(),
|
||||
GuildFeatures::InvitesClosed
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::from_str("INVALID").unwrap_err().to_string(),
|
||||
Error::Guild(GuildError::InvalidGuildFeature).to_string()
|
||||
);
|
||||
}
|
||||
|
||||
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
|
||||
#[cfg_attr(not(target_arch = "wasm32"), test)]
|
||||
fn test_to_str() {
|
||||
assert_eq!(GuildFeatures::ActivitiesAlpha.to_str(), "ACTIVITIES_ALPHA");
|
||||
assert_eq!(
|
||||
GuildFeatures::ActivitiesEmployee.to_str(),
|
||||
"ACTIVITIES_EMPLOYEE"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::ActivitiesInternalDev.to_str(),
|
||||
"ACTIVITIES_INTERNAL_DEV"
|
||||
);
|
||||
assert_eq!(GuildFeatures::AnimatedBanner.to_str(), "ANIMATED_BANNER");
|
||||
assert_eq!(GuildFeatures::AnimatedIcon.to_str(), "ANIMATED_ICON");
|
||||
assert_eq!(
|
||||
GuildFeatures::ApplicationCommandPermissionsV2.to_str(),
|
||||
"APPLICATION_COMMAND_PERMISSIONS_V2"
|
||||
);
|
||||
assert_eq!(GuildFeatures::AutoModeration.to_str(), "AUTO_MODERATION");
|
||||
assert_eq!(
|
||||
GuildFeatures::AutoModTriggerKeywordFilter.to_str(),
|
||||
"AUTO_MOD_TRIGGER_KEYWORD_FILTER"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::AutoModTriggerMLSpamFilter.to_str(),
|
||||
"AUTO_MOD_TRIGGER_ML_SPAM_FILTER"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::AutoModTriggerSpamLinkFilter.to_str(),
|
||||
"AUTO_MOD_TRIGGER_SPAM_LINK_FILTER"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::AutoModTriggerUserProfile.to_str(),
|
||||
"AUTO_MOD_TRIGGER_USER_PROFILE"
|
||||
);
|
||||
assert_eq!(GuildFeatures::Banner.to_str(), "BANNER");
|
||||
assert_eq!(GuildFeatures::Bfg.to_str(), "BFG");
|
||||
assert_eq!(
|
||||
GuildFeatures::BoostingTiersExperimentMediumGuild.to_str(),
|
||||
"BOOSTING_TIERS_EXPERIMENT_MEDIUM_GUILD"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::BoostingTiersExperimentSmallGuild.to_str(),
|
||||
"BOOSTING_TIERS_EXPERIMENT_SMALL_GUILD"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::BotDeveloperEarlyAccess.to_str(),
|
||||
"BOT_DEVELOPER_EARLY_ACCESS"
|
||||
);
|
||||
assert_eq!(GuildFeatures::BurstReactions.to_str(), "BURST_REACTIONS");
|
||||
assert_eq!(GuildFeatures::CommunityCanary.to_str(), "COMMUNITY_CANARY");
|
||||
assert_eq!(
|
||||
GuildFeatures::CommunityExpLargeGated.to_str(),
|
||||
"COMMUNITY_EXP_LARGE_GATED"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::CommunityExpLargeUngated.to_str(),
|
||||
"COMMUNITY_EXP_LARGE_UNGATED"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::CommunityExpMedium.to_str(),
|
||||
"COMMUNITY_EXP_MEDIUM"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::ChannelEmojisGenerated.to_str(),
|
||||
"CHANNEL_EMOJIS_GENERATED"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::ChannelHighlights.to_str(),
|
||||
"CHANNEL_HIGHLIGHTS"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::ChannelHighlightsDisabled.to_str(),
|
||||
"CHANNEL_HIGHLIGHTS_DISABLED"
|
||||
);
|
||||
assert_eq!(GuildFeatures::ClydeEnabled.to_str(), "CLYDE_ENABLED");
|
||||
assert_eq!(
|
||||
GuildFeatures::ClydeExperimentEnabled.to_str(),
|
||||
"CLYDE_EXPERIMENT_ENABLED"
|
||||
);
|
||||
assert_eq!(GuildFeatures::ClydeDisabled.to_str(), "CLYDE_DISABLED");
|
||||
assert_eq!(GuildFeatures::Community.to_str(), "COMMUNITY");
|
||||
assert_eq!(
|
||||
GuildFeatures::CreatorAcceptedNewTerms.to_str(),
|
||||
"CREATOR_ACCEPTED_NEW_TERMS"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::CreatorMonetizable.to_str(),
|
||||
"CREATOR_MONETIZABLE"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::CreatorMonetizableDisabled.to_str(),
|
||||
"CREATOR_MONETIZABLE_DISABLED"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::CreatorMonetizablePendingNewOwnerOnboarding.to_str(),
|
||||
"CREATOR_MONETIZABLE_PENDING_NEW_OWNER_ONBOARDING"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::CreatorMonetizableProvisional.to_str(),
|
||||
"CREATOR_MONETIZABLE_PROVISIONAL"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::CreatorMonetizableRestricted.to_str(),
|
||||
"CREATOR_MONETIZABLE_RESTRICTED"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::CreatorMonetizableWhiteglove.to_str(),
|
||||
"CREATOR_MONETIZABLE_WHITEGLOVE"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::CreatorMonetizableApplicationAllowlist.to_str(),
|
||||
"CREATOR_MONETIZABLE_APPLICATION_ALLOWLIST"
|
||||
);
|
||||
assert_eq!(GuildFeatures::CreateStorePage.to_str(), "CREATE_STORE_PAGE");
|
||||
assert_eq!(
|
||||
GuildFeatures::DeveloperSupportServer.to_str(),
|
||||
"DEVELOPER_SUPPORT_SERVER"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::DiscoverableDisabled.to_str(),
|
||||
"DISCOVERABLE_DISABLED"
|
||||
);
|
||||
assert_eq!(GuildFeatures::Discoverable.to_str(), "DISCOVERABLE");
|
||||
assert_eq!(
|
||||
GuildFeatures::EnabledDiscoverableBefore.to_str(),
|
||||
"ENABLED_DISCOVERABLE_BEFORE"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::ExposedToActivitiesWTPExperiment.to_str(),
|
||||
"EXPOSED_TO_ACTIVITIES_WTP_EXPERIMENT"
|
||||
);
|
||||
assert_eq!(GuildFeatures::GuestsEnabled.to_str(), "GUESTS_ENABLED");
|
||||
assert_eq!(
|
||||
GuildFeatures::GuildAutomodDefaultList.to_str(),
|
||||
"GUILD_AUTOMOD_DEFAULT_LIST"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::GuildCommunicationDisabledGuilds.to_str(),
|
||||
"GUILD_COMMUNICATION_DISABLED_GUILDS"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::GuildHomeDeprecationOverride.to_str(),
|
||||
"GUILD_HOME_DEPRECATION_OVERRIDE"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::GuildHomeOverride.to_str(),
|
||||
"GUILD_HOME_OVERRIDE"
|
||||
);
|
||||
assert_eq!(GuildFeatures::GuildHomeTest.to_str(), "GUILD_HOME_TEST");
|
||||
assert_eq!(
|
||||
GuildFeatures::GuildMemberVerificationExperiment.to_str(),
|
||||
"GUILD_MEMBER_VERIFICATION_EXPERIMENT"
|
||||
);
|
||||
assert_eq!(GuildFeatures::GuildOnboarding.to_str(), "GUILD_ONBOARDING");
|
||||
assert_eq!(
|
||||
GuildFeatures::GuildOnboardingAdminOnly.to_str(),
|
||||
"GUILD_ONBOARDING_ADMIN_ONLY"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::GuildOnboardingEverEnabled.to_str(),
|
||||
"GUILD_ONBOARDING_EVER_ENABLED"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::GuildOnboardingHasPrompts.to_str(),
|
||||
"GUILD_ONBOARDING_HAS_PROMPTS"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::GuildRoleSubscription.to_str(),
|
||||
"GUILD_ROLE_SUBSCRIPTION"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::GuildRoleSubscriptionPurchaseFeedbackLoop.to_str(),
|
||||
"GUILD_ROLE_SUBSCRIPTION_PURCHASE_FEEDBACK_LOOP"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::GuildRoleSubscriptionTrials.to_str(),
|
||||
"GUILD_ROLE_SUBSCRIPTION_TRIALS"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::GuildServerGuide.to_str(),
|
||||
"GUILD_SERVER_GUIDE"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::GuildWebPageVanityURL.to_str(),
|
||||
"GUILD_WEB_PAGE_VANITY_URL"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::HadEarlyActivitiesAccess.to_str(),
|
||||
"HAD_EARLY_ACTIVITIES_ACCESS"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::HasDirectoryEntry.to_str(),
|
||||
"HAS_DIRECTORY_ENTRY"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::HideFromExperimentUi.to_str(),
|
||||
"HIDE_FROM_EXPERIMENT_UI"
|
||||
);
|
||||
assert_eq!(GuildFeatures::Hub.to_str(), "HUB");
|
||||
assert_eq!(
|
||||
GuildFeatures::IncreasedThreadLimit.to_str(),
|
||||
"INCREASED_THREAD_LIMIT"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::InternalEmployeeOnly.to_str(),
|
||||
"INTERNAL_EMPLOYEE_ONLY"
|
||||
);
|
||||
assert_eq!(GuildFeatures::InviteSplash.to_str(), "INVITE_SPLASH");
|
||||
assert_eq!(GuildFeatures::InvitesDisabled.to_str(), "INVITES_DISABLED");
|
||||
assert_eq!(GuildFeatures::LinkedToHub.to_str(), "LINKED_TO_HUB");
|
||||
assert_eq!(
|
||||
GuildFeatures::MarketplacesConnectionRoles.to_str(),
|
||||
"MARKETPLACES_CONNECTION_ROLES"
|
||||
);
|
||||
assert_eq!(GuildFeatures::MemberProfiles.to_str(), "MEMBER_PROFILES");
|
||||
assert_eq!(
|
||||
GuildFeatures::MemberVerificationGateEnabled.to_str(),
|
||||
"MEMBER_VERIFICATION_GATE_ENABLED"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::MemberVerificationManualApproval.to_str(),
|
||||
"MEMBER_VERIFICATION_MANUAL_APPROVAL"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::MobileWebRoleSubscriptionPurchasePage.to_str(),
|
||||
"MOBILE_WEB_ROLE_SUBSCRIPTION_PURCHASE_PAGE"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::MonetizationEnabled.to_str(),
|
||||
"MONETIZATION_ENABLED"
|
||||
);
|
||||
assert_eq!(GuildFeatures::MoreEmoji.to_str(), "MORE_EMOJI");
|
||||
assert_eq!(GuildFeatures::MoreStickers.to_str(), "MORE_STICKERS");
|
||||
assert_eq!(GuildFeatures::News.to_str(), "NEWS");
|
||||
assert_eq!(
|
||||
GuildFeatures::NewThreadPermissions.to_str(),
|
||||
"NEW_THREAD_PERMISSIONS"
|
||||
);
|
||||
assert_eq!(GuildFeatures::Partnered.to_str(), "PARTNERED");
|
||||
assert_eq!(
|
||||
GuildFeatures::PremiumTier3Override.to_str(),
|
||||
"PREMIUM_TIER_3_OVERRIDE"
|
||||
);
|
||||
assert_eq!(GuildFeatures::PreviewEnabled.to_str(), "PREVIEW_ENABLED");
|
||||
assert_eq!(
|
||||
GuildFeatures::RaidAlertsDisabled.to_str(),
|
||||
"RAID_ALERTS_DISABLED"
|
||||
);
|
||||
assert_eq!(GuildFeatures::RelayEnabled.to_str(), "RELAY_ENABLED");
|
||||
assert_eq!(
|
||||
GuildFeatures::RestrictSpamRiskGuild.to_str(),
|
||||
"RESTRICT_SPAM_RISK_GUILD"
|
||||
);
|
||||
assert_eq!(GuildFeatures::RoleIcons.to_str(), "ROLE_ICONS");
|
||||
assert_eq!(
|
||||
GuildFeatures::RoleSubscriptionsAvailableForPurchase.to_str(),
|
||||
"ROLE_SUBSCRIPTIONS_AVAILABLE_FOR_PURCHASE"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::RoleSubscriptionsEnabled.to_str(),
|
||||
"ROLE_SUBSCRIPTIONS_ENABLED"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::RoleSubscriptionsEnabledForPurchase.to_str(),
|
||||
"ROLE_SUBSCRIPTIONS_ENABLED_FOR_PURCHASE"
|
||||
);
|
||||
assert_eq!(GuildFeatures::Shard.to_str(), "SHARD");
|
||||
assert_eq!(
|
||||
GuildFeatures::SharedCanvasFriendsAndFamilyTest.to_str(),
|
||||
"SHARED_CANVAS_FRIENDS_AND_FAMILY_TEST"
|
||||
);
|
||||
assert_eq!(GuildFeatures::Soundboard.to_str(), "SOUNDBOARD");
|
||||
assert_eq!(
|
||||
GuildFeatures::SummariesEnabled.to_str(),
|
||||
"SUMMARIES_ENABLED"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::SummariesEnabledGa.to_str(),
|
||||
"SUMMARIES_ENABLED_GA"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::SummariesDisabledByUser.to_str(),
|
||||
"SUMMARIES_DISABLED_BY_USER"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::SummariesEnabledByUser.to_str(),
|
||||
"SUMMARIES_ENABLED_BY_USER"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::TextInStageEnabled.to_str(),
|
||||
"TEXT_IN_STAGE_ENABLED"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::TextInVoiceEnabled.to_str(),
|
||||
"TEXT_IN_VOICE_ENABLED"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::ThreadsEnabledTesting.to_str(),
|
||||
"THREADS_ENABLED_TESTING"
|
||||
);
|
||||
assert_eq!(GuildFeatures::ThreadsEnabled.to_str(), "THREADS_ENABLED");
|
||||
assert_eq!(
|
||||
GuildFeatures::ThreadDefaultAutoArchiveDuration.to_str(),
|
||||
"THREAD_DEFAULT_AUTO_ARCHIVE_DURATION"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::ThreadsOnlyChannel.to_str(),
|
||||
"THREADS_ONLY_CHANNEL"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::TicketedEventsEnabled.to_str(),
|
||||
"TICKETED_EVENTS_ENABLED"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::TicketingEnabled.to_str(),
|
||||
"TICKETING_ENABLED"
|
||||
);
|
||||
assert_eq!(GuildFeatures::VanityUrl.to_str(), "VANITY_URL");
|
||||
assert_eq!(GuildFeatures::Verified.to_str(), "VERIFIED");
|
||||
assert_eq!(GuildFeatures::VipRegions.to_str(), "VIP_REGIONS");
|
||||
assert_eq!(
|
||||
GuildFeatures::VoiceChannelEffects.to_str(),
|
||||
"VOICE_CHANNEL_EFFECTS"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::WelcomeScreenEnabled.to_str(),
|
||||
"WELCOME_SCREEN_ENABLED"
|
||||
);
|
||||
assert_eq!(GuildFeatures::AliasableNames.to_str(), "ALIASABLE_NAMES");
|
||||
assert_eq!(
|
||||
GuildFeatures::AllowInvalidChannelName.to_str(),
|
||||
"ALLOW_INVALID_CHANNEL_NAME"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::AllowUnnamedChannels.to_str(),
|
||||
"ALLOW_UNNAMED_CHANNELS"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::CrossChannelReplies.to_str(),
|
||||
"CROSS_CHANNEL_REPLIES"
|
||||
);
|
||||
assert_eq!(
|
||||
GuildFeatures::IrcLikeCategoryNames.to_str(),
|
||||
"IRC_LIKE_CATEGORY_NAMES"
|
||||
);
|
||||
assert_eq!(GuildFeatures::InvitesClosed.to_str(), "INVITES_CLOSED");
|
||||
}
|
||||
}
|
||||
|
||||
mod domains_configuration {
|
||||
|
@ -116,4 +947,108 @@ mod entities {
|
|||
assert_ne!(emoji.id, another_emoji.id);
|
||||
assert_ne!(emoji, another_emoji);
|
||||
}
|
||||
|
||||
mod guild {
|
||||
use std::hash::{Hash, Hasher};
|
||||
|
||||
use chorus::types::{Guild, GuildInvite};
|
||||
|
||||
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
|
||||
#[cfg_attr(not(target_arch = "wasm32"), test)]
|
||||
fn guild_hash() {
|
||||
let id: u64 = 1;
|
||||
let mut guild1 = Guild::default();
|
||||
let mut guild2 = Guild::default();
|
||||
guild1.id = id.into();
|
||||
guild2.id = id.into();
|
||||
let mut hasher1 = std::collections::hash_map::DefaultHasher::new();
|
||||
guild1.hash(&mut hasher1);
|
||||
|
||||
let mut hasher2 = std::collections::hash_map::DefaultHasher::new();
|
||||
guild2.hash(&mut hasher2);
|
||||
|
||||
assert_eq!(hasher1.finish(), hasher2.finish());
|
||||
}
|
||||
|
||||
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
|
||||
#[cfg_attr(not(target_arch = "wasm32"), test)]
|
||||
fn guild_invite_hash() {
|
||||
let id: u64 = 1;
|
||||
let mut invite1 = GuildInvite::default();
|
||||
let mut invite2 = GuildInvite::default();
|
||||
invite1.channel_id = id.into();
|
||||
invite2.channel_id = id.into();
|
||||
invite1.guild_id = id.into();
|
||||
invite2.guild_id = id.into();
|
||||
let mut hasher1 = std::collections::hash_map::DefaultHasher::new();
|
||||
invite1.hash(&mut hasher1);
|
||||
|
||||
let mut hasher2 = std::collections::hash_map::DefaultHasher::new();
|
||||
invite2.hash(&mut hasher2);
|
||||
|
||||
assert_eq!(hasher1.finish(), hasher2.finish());
|
||||
}
|
||||
|
||||
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
|
||||
#[cfg_attr(not(target_arch = "wasm32"), test)]
|
||||
fn guild_partial_eq() {
|
||||
let id: u64 = 1;
|
||||
let mut guild1 = Guild::default();
|
||||
let mut guild2 = Guild::default();
|
||||
guild1.id = id.into();
|
||||
guild2.id = id.into();
|
||||
|
||||
assert_eq!(guild1, guild2);
|
||||
}
|
||||
}
|
||||
|
||||
mod relationship {
|
||||
use chorus::types::{IntoShared, Relationship, User};
|
||||
|
||||
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
|
||||
#[cfg_attr(not(target_arch = "wasm32"), test)]
|
||||
fn relationship_partial_eq() {
|
||||
let user = User::default();
|
||||
// These 2 users are different, because they do not have the same Snowflake "id".
|
||||
let user_2 = User::default();
|
||||
let relationship_1 = Relationship {
|
||||
id: 32_u64.into(),
|
||||
relationship_type: chorus::types::RelationshipType::Friends,
|
||||
nickname: Some("Xenia".to_string()),
|
||||
user: user.into_public_user().into_shared(),
|
||||
since: None,
|
||||
};
|
||||
|
||||
let relationship_2 = Relationship {
|
||||
id: 32_u64.into(),
|
||||
relationship_type: chorus::types::RelationshipType::Friends,
|
||||
nickname: Some("Xenia".to_string()),
|
||||
user: user_2.into_public_user().into_shared(),
|
||||
since: None,
|
||||
};
|
||||
|
||||
// This should succeed, even though the two users' IDs are different. This is because
|
||||
// `User` is only `PartialEq`, and the actual user object is not checked, since the
|
||||
// `RwLock` would have to be locked.
|
||||
assert_eq!(relationship_1, relationship_2);
|
||||
}
|
||||
}
|
||||
|
||||
mod message {
|
||||
use chorus::types::{Message, Snowflake};
|
||||
|
||||
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
|
||||
#[cfg_attr(not(target_arch = "wasm32"), test)]
|
||||
fn message_partial_eq() {
|
||||
let id: Snowflake = 1_u64.into();
|
||||
let mut message1 = Message::default();
|
||||
let mut message2 = Message::default();
|
||||
message1.id = id;
|
||||
message1.channel_id = id;
|
||||
message2.id = id;
|
||||
message2.channel_id = id;
|
||||
|
||||
assert_eq!(message1, message2);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -0,0 +1,18 @@
|
|||
use chorus::types::{PublicUser, Snowflake, User};
|
||||
|
||||
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
|
||||
#[cfg_attr(not(target_arch = "wasm32"), test)]
|
||||
fn to_public_user() {
|
||||
let mut user = User::default();
|
||||
let mut public_user = PublicUser {
|
||||
username: Some("".to_string()),
|
||||
discriminator: Some("".to_string()),
|
||||
..Default::default()
|
||||
};
|
||||
let id: Snowflake = 1_u64.into();
|
||||
user.id = id;
|
||||
public_user.id = id;
|
||||
|
||||
let from_user = user.into_public_user();
|
||||
assert_eq!(public_user, from_user);
|
||||
}
|
Loading…
Reference in New Issue