From 6d747bc50424580304c655ab6688d5df17fcf757 Mon Sep 17 00:00:00 2001 From: Zertex Date: Sat, 27 May 2023 13:41:23 -0400 Subject: [PATCH 01/42] Rename APIError -> APIErrorPayload to solve conflicting name --- src/types/errors.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/types/errors.rs b/src/types/errors.rs index 63f6ceb..c4b5992 100644 --- a/src/types/errors.rs +++ b/src/types/errors.rs @@ -48,7 +48,7 @@ pub struct ErrorField { } #[derive(Serialize, Deserialize, Debug)] -pub struct APIError { +pub struct APIErrorPayload { pub message: String, pub code: String, } From 665a3b366713966e443eb7c34fcaa02714a4fed0 Mon Sep 17 00:00:00 2001 From: Zertex Date: Sat, 27 May 2023 13:50:28 -0400 Subject: [PATCH 02/42] rename APIError in ErrorField vec as well --- src/types/entities/guild.rs | 2 +- src/types/entities/role.rs | 16 ++++++++++++++-- src/types/errors.rs | 2 +- src/types/mod.rs | 3 ++- 4 files changed, 18 insertions(+), 5 deletions(-) diff --git a/src/types/entities/guild.rs b/src/types/entities/guild.rs index f3f03f7..d10fa5e 100644 --- a/src/types/entities/guild.rs +++ b/src/types/entities/guild.rs @@ -33,7 +33,7 @@ pub struct Guild { #[cfg_attr(feature = "sqlx", sqlx(skip))] pub emojis: Vec, #[cfg_attr(feature = "sqlx", sqlx(skip))] - pub features: Vec, + pub features: String, // TODO: Make this a 'simple-array' pub application_id: Option, pub system_channel_id: Option, pub system_channel_flags: Option, diff --git a/src/types/entities/role.rs b/src/types/entities/role.rs index f427dc9..8553998 100644 --- a/src/types/entities/role.rs +++ b/src/types/entities/role.rs @@ -16,8 +16,10 @@ pub struct RoleObject { pub permissions: String, pub managed: bool, pub mentionable: bool, - // to:do add role tags https://discord.com/developers/docs/topics/permissions#role-object-role-tags-structure - //pub tags: Option + #[cfg(feature = "sqlx")] + pub tags: Option>, + #[cfg(not(feature = "sqlx"))] + pub tags: Option, } #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] @@ -27,3 +29,13 @@ pub struct RoleSubscriptionData { pub total_months_subscribed: u32, pub is_renewal: bool, } + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub struct RoleTags { + pub bot_id: Option, + pub integration_id: Option, + pub premium_subscriber: Option, + pub subscription_listing_id: Option, + pub available_for_purchase: Option, + pub guild_connections: Option, +} diff --git a/src/types/errors.rs b/src/types/errors.rs index c4b5992..a66b192 100644 --- a/src/types/errors.rs +++ b/src/types/errors.rs @@ -44,7 +44,7 @@ pub struct IntermittentError { #[derive(Serialize, Deserialize, Debug, Default)] pub struct ErrorField { #[serde(default)] - pub _errors: Vec, + pub _errors: Vec, } #[derive(Serialize, Deserialize, Debug)] diff --git a/src/types/mod.rs b/src/types/mod.rs index 8554011..7ad0ada 100644 --- a/src/types/mod.rs +++ b/src/types/mod.rs @@ -1,6 +1,7 @@ pub use config::*; pub use entities::*; -pub use errors::*; + +//pub use errors::*; pub use events::*; pub use interfaces::*; pub use schema::*; From 80e60901d8eec5e0231b662a731ed70bc70d1089 Mon Sep 17 00:00:00 2001 From: Zertex Date: Sat, 27 May 2023 13:50:55 -0400 Subject: [PATCH 03/42] uncomment, oops --- src/types/mod.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/types/mod.rs b/src/types/mod.rs index 7ad0ada..8554011 100644 --- a/src/types/mod.rs +++ b/src/types/mod.rs @@ -1,7 +1,6 @@ pub use config::*; pub use entities::*; - -//pub use errors::*; +pub use errors::*; pub use events::*; pub use interfaces::*; pub use schema::*; From 73790fbf2a16e76f93160899a2d67e648609644d Mon Sep 17 00:00:00 2001 From: Zertex Date: Sun, 28 May 2023 02:39:24 -0400 Subject: [PATCH 04/42] Change integer datatypes to be 'i32' as required by sqlx --- src/types/entities/guild.rs | 37 ++++++++++++++++++++++--------------- 1 file changed, 22 insertions(+), 15 deletions(-) diff --git a/src/types/entities/guild.rs b/src/types/entities/guild.rs index 3a6b11a..f3f325b 100644 --- a/src/types/entities/guild.rs +++ b/src/types/entities/guild.rs @@ -15,20 +15,22 @@ pub struct Guild { pub id: Snowflake, pub name: Option, pub icon: Option, + #[cfg_attr(feature = "sqlx", sqlx(skip))] pub icon_hash: Option, pub splash: Option, pub discovery_splash: Option, #[cfg_attr(feature = "sqlx", sqlx(skip))] pub owner: bool, // True if requesting user is owner pub owner_id: Option, + #[cfg_attr(feature = "sqlx", sqlx(skip))] pub permissions: Option, pub afk_channel_id: Option, - pub afk_timeout: Option, + pub afk_timeout: Option, pub widget_enabled: Option, pub widget_channel_id: Option, - pub verification_level: Option, - pub default_message_notifications: Option, - pub explicit_content_filter: Option, + pub verification_level: Option, + pub default_message_notifications: Option, + pub explicit_content_filter: Option, #[cfg_attr(feature = "sqlx", sqlx(skip))] pub roles: Vec, #[cfg_attr(feature = "sqlx", sqlx(skip))] @@ -37,27 +39,32 @@ pub struct Guild { pub features: Option>, pub application_id: Option, pub system_channel_id: Option, - pub system_channel_flags: Option, + pub system_channel_flags: Option, pub rules_channel_id: Option, + #[cfg_attr(feature = "sqlx", sqlx(skip))] pub rules_channel: Option, - pub max_presences: Option, - pub max_members: Option, + pub max_presences: Option, + pub max_members: Option, + #[cfg_attr(feature = "sqlx", sqlx(skip))] pub vanity_url_code: Option, pub description: Option, pub banner: Option, - pub premium_tier: Option, - pub premium_subscription_count: Option, + pub premium_tier: Option, + pub premium_subscription_count: Option, pub preferred_locale: Option, pub public_updates_channel_id: Option, - pub max_video_channel_users: Option, - pub max_stage_video_channel_users: Option, - pub approximate_member_count: Option, - pub approximate_presence_count: Option, + pub max_video_channel_users: Option, + #[cfg_attr(feature = "sqlx", sqlx(skip))] + pub max_stage_video_channel_users: Option, + #[cfg_attr(feature = "sqlx", sqlx(skip))] + pub approximate_member_count: Option, + #[cfg_attr(feature = "sqlx", sqlx(skip))] + pub approximate_presence_count: Option, #[cfg(feature = "sqlx")] pub welcome_screen: Option>, #[cfg(not(feature = "sqlx"))] pub welcome_screen: Option, - pub nsfw_level: Option, + pub nsfw_level: Option, #[cfg_attr(feature = "sqlx", sqlx(skip))] pub stickers: Option>, pub premium_progress_bar_enabled: Option, @@ -75,7 +82,7 @@ pub struct Guild { pub voice_states: Option>, #[cfg_attr(feature = "sqlx", sqlx(skip))] pub webhooks: Option>, - pub mfa_level: Option, + pub mfa_level: Option, pub region: Option, } From bab1f0ed52bb2bd8ea94302581ba77cd4a37190e Mon Sep 17 00:00:00 2001 From: Zertex Date: Sun, 28 May 2023 02:42:09 -0400 Subject: [PATCH 05/42] Add custom implementation to allow simple-array behaviour for GuildFeatures --- src/types/config/types/guild_configuration.rs | 412 +++++++++++++++++- src/types/entities/guild.rs | 4 +- src/types/errors.rs | 9 + 3 files changed, 419 insertions(+), 6 deletions(-) diff --git a/src/types/config/types/guild_configuration.rs b/src/types/config/types/guild_configuration.rs index e98c6c5..2dc4d5b 100644 --- a/src/types/config/types/guild_configuration.rs +++ b/src/types/config/types/guild_configuration.rs @@ -1,8 +1,20 @@ use serde::{Deserialize, Serialize}; +#[cfg(feature = "sqlx")] +use sqlx::{ + database::{HasArguments, HasValueRef}, + encode::IsNull, + error::BoxDynError, + Decode, Encode, MySql, +}; +use std::fmt::{Display, Formatter}; +use std::io::Write; +use std::ops::{Deref, DerefMut}; +use std::str::FromStr; use crate::types::config::types::subconfigs::guild::{ autojoin::AutoJoinConfiguration, discovery::DiscoverConfiguration, }; +use crate::types::{Error, GuildError}; #[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "SCREAMING_SNAKE_CASE")] @@ -19,7 +31,7 @@ pub enum GuildFeatures { AutoModTriggerSpamLinkFilter, AutoModTriggerUserProfile, Banner, - BFG, + Bfg, BoostingTiersExperimentMediumGuild, BoostingTiersExperimentSmallGuild, BotDeveloperEarlyAccess, @@ -67,7 +79,7 @@ pub enum GuildFeatures { GuildWebPageVanityURL, HadEarlyActivitiesAccess, HasDirectoryEntry, - HideFromExperimentUI, + HideFromExperimentUi, Hub, IncreasedThreadLimit, InternalEmployeeOnly, @@ -85,6 +97,7 @@ pub enum GuildFeatures { News, NewThreadPermissions, Partnered, + #[serde(rename = "PREMIUM_TIER_3_OVERRIDE")] PremiumTier3Override, PreviewEnabled, RaidAlertsDisabled, @@ -98,7 +111,7 @@ pub enum GuildFeatures { SharedCanvasFriendsAndFamilyTest, Soundboard, SummariesEnabled, - SummariesEnabledGA, + SummariesEnabledGa, SummariesDisabledByUser, SummariesEnabledByUser, TextInStageEnabled, @@ -109,11 +122,400 @@ pub enum GuildFeatures { ThreadsOnlyChannel, TicketedEventsEnabled, TicketingEnabled, - VanityUrls, + VanityUrl, Verified, - VIPRegions, + VipRegions, VoiceChannelEffects, WelcomeScreenEnabled, + + /// Spacebar Specific + AliasableNames, + AllowInvalidChannelName, + AllowUnnamedChannels, + CrossChannelReplies, + IrcLikeCategoryNames, + InvitesClosed, +} + +#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)] +pub struct GuildFeaturesList(Vec); + +impl Deref for GuildFeaturesList { + type Target = Vec; + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl DerefMut for GuildFeaturesList { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +impl Display for GuildFeaturesList { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + let features = self + .iter() + .map(|x| serde_json::to_string(x).unwrap().replace('"', "")) + .collect::>() + .join(","); + write!(f, "{features}") + } +} + +#[cfg(feature = "sqlx")] +impl<'r> sqlx::Decode<'r, sqlx::MySql> for GuildFeaturesList { + fn decode(value: >::ValueRef) -> Result { + let v = <&str as Decode>::decode(value)?; + Ok(Self( + v.split(',') + .filter(|f| !f.is_empty()) + .flat_map(GuildFeatures::from_str) + .collect(), + )) + } +} + +#[cfg(feature = "sqlx")] +impl<'q> sqlx::Encode<'q, sqlx::MySql> for GuildFeaturesList { + fn encode_by_ref(&self, buf: &mut >::ArgumentBuffer) -> IsNull { + if self.is_empty() { + return IsNull::Yes; + } + let features = self + .iter() + .map(|x| x.to_str()) + .collect::>() + .join(","); + + let _ = buf.write(features.as_bytes()); + IsNull::No + } +} + +#[cfg(feature = "sqlx")] +impl sqlx::Type for GuildFeaturesList { + fn type_info() -> sqlx::mysql::MySqlTypeInfo { + <&str as sqlx::Type>::type_info() + } + + fn compatible(ty: &sqlx::mysql::MySqlTypeInfo) -> bool { + <&str as sqlx::Type>::compatible(ty) + } +} + +#[cfg(feature = "sqlx")] +impl sqlx::TypeInfo for GuildFeaturesList { + fn is_null(&self) -> bool { + false + } + + fn name(&self) -> &str { + "TEXT" + } +} + +impl FromStr for GuildFeatures { + type Err = Error; + + fn from_str(s: &str) -> Result { + let s = s.to_ascii_uppercase(); + match s.as_str() { + "ACTIVITIES_ALPHA" => Ok(GuildFeatures::ActivitiesAlpha), + "ACTIVITIES_EMPLOYEE" => Ok(GuildFeatures::ActivitiesEmployee), + "ACTIVITIES_INTERNAL_DEV" => Ok(GuildFeatures::ActivitiesInternalDev), + "ANIMATED_BANNER" => Ok(GuildFeatures::AnimatedBanner), + "ANIMATED_ICON" => Ok(GuildFeatures::AnimatedIcon), + "APPLICATION_COMMAND_PERMISSIONS_V2" => { + Ok(GuildFeatures::ApplicationCommandPermissionsV2) + } + "AUTO_MODERATION" => Ok(GuildFeatures::AutoModeration), + "AUTO_MOD_TRIGGER_KEYWORD_FILTER" => Ok(GuildFeatures::AutoModTriggerKeywordFilter), + "AUTO_MOD_TRIGGER_ML_SPAM_FILTER" => Ok(GuildFeatures::AutoModTriggerMLSpamFilter), + "AUTO_MOD_TRIGGER_SPAM_LINK_FILTER" => Ok(GuildFeatures::AutoModTriggerSpamLinkFilter), + "AUTO_MOD_TRIGGER_USER_PROFILE" => Ok(GuildFeatures::AutoModTriggerUserProfile), + "BANNER" => Ok(GuildFeatures::Banner), + "BFG" => Ok(GuildFeatures::Bfg), + "BOOSTING_TIERS_EXPERIMENT_MEDIUM_GUILD" => { + Ok(GuildFeatures::BoostingTiersExperimentMediumGuild) + } + "BOOSTING_TIERS_EXPERIMENT_SMALL_GUILD" => { + Ok(GuildFeatures::BoostingTiersExperimentSmallGuild) + } + "BOT_DEVELOPER_EARLY_ACCESS" => Ok(GuildFeatures::BotDeveloperEarlyAccess), + "BURST_REACTIONS" => Ok(GuildFeatures::BurstReactions), + "COMMUNITY_CANARY" => Ok(GuildFeatures::CommunityCanary), + "COMMUNITY_EXP_LARGE_GATED" => Ok(GuildFeatures::CommunityExpLargeGated), + "COMMUNITY_EXP_LARGE_UNGATED" => Ok(GuildFeatures::CommunityExpLargeUngated), + "COMMUNITY_EXP_MEDIUM" => Ok(GuildFeatures::CommunityExpMedium), + "CHANNEL_EMOJIS_GENERATED" => Ok(GuildFeatures::ChannelEmojisGenerated), + "CHANNEL_HIGHLIGHTS" => Ok(GuildFeatures::ChannelHighlights), + "CHANNEL_HIGHLIGHTS_DISABLED" => Ok(GuildFeatures::ChannelHighlightsDisabled), + "CLYDE_ENABLED" => Ok(GuildFeatures::ClydeEnabled), + "CLYDE_EXPERIMENT_ENABLED" => Ok(GuildFeatures::ClydeExperimentEnabled), + "CLYDE_DISABLED" => Ok(GuildFeatures::ClydeDisabled), + "COMMUNITY" => Ok(GuildFeatures::Community), + "CREATOR_ACCEPTED_NEW_TERMS" => Ok(GuildFeatures::CreatorAcceptedNewTerms), + "CREATOR_MONETIZABLE" => Ok(GuildFeatures::CreatorMonetizable), + "CREATOR_MONETIZABLE_DISABLED" => Ok(GuildFeatures::CreatorMonetizableDisabled), + "CREATOR_MONETIZABLE_PENDING_NEW_OWNER_ONBOARDING" => { + Ok(GuildFeatures::CreatorMonetizablePendingNewOwnerOnboarding) + } + "CREATOR_MONETIZABLE_PROVISIONAL" => Ok(GuildFeatures::CreatorMonetizableProvisional), + "CREATOR_MONETIZABLE_RESTRICTED" => Ok(GuildFeatures::CreatorMonetizableRestricted), + "CREATOR_MONETIZABLE_WHITEGLOVE" => Ok(GuildFeatures::CreatorMonetizableWhiteglove), + "CREATOR_MONETIZABLE_APPLICATION_ALLOWLIST" => { + Ok(GuildFeatures::CreatorMonetizableApplicationAllowlist) + } + "CREATE_STORE_PAGE" => Ok(GuildFeatures::CreateStorePage), + "DEVELOPER_SUPPORT_SERVER" => Ok(GuildFeatures::DeveloperSupportServer), + "DISCOVERABLE_DISABLED" => Ok(GuildFeatures::DiscoverableDisabled), + "DISCOVERABLE" => Ok(GuildFeatures::Discoverable), + "ENABLED_DISCOVERABLE_BEFORE" => Ok(GuildFeatures::EnabledDiscoverableBefore), + "EXPOSED_TO_ACTIVITIES_WTP_EXPERIMENT" => { + Ok(GuildFeatures::ExposedToActivitiesWTPExperiment) + } + "GUESTS_ENABLED" => Ok(GuildFeatures::GuestsEnabled), + "GUILD_AUTOMOD_DEFAULT_LIST" => Ok(GuildFeatures::GuildAutomodDefaultList), + "GUILD_COMMUNICATION_DISABLED_GUILDS" => { + Ok(GuildFeatures::GuildCommunicationDisabledGuilds) + } + "GUILD_HOME_DEPRECATION_OVERRIDE" => Ok(GuildFeatures::GuildHomeDeprecationOverride), + "GUILD_HOME_OVERRIDE" => Ok(GuildFeatures::GuildHomeOverride), + "GUILD_HOME_TEST" => Ok(GuildFeatures::GuildHomeTest), + "GUILD_MEMBER_VERIFICATION_EXPERIMENT" => { + Ok(GuildFeatures::GuildMemberVerificationExperiment) + } + "GUILD_ONBOARDING" => Ok(GuildFeatures::GuildOnboarding), + "GUILD_ONBOARDING_ADMIN_ONLY" => Ok(GuildFeatures::GuildOnboardingAdminOnly), + "GUILD_ONBOARDING_EVER_ENABLED" => Ok(GuildFeatures::GuildOnboardingEverEnabled), + "GUILD_ONBOARDING_HAS_PROMPTS" => Ok(GuildFeatures::GuildOnboardingHasPrompts), + "GUILD_ROLE_SUBSCRIPTION" => Ok(GuildFeatures::GuildRoleSubscription), + "GUILD_ROLE_SUBSCRIPTION_PURCHASE_FEEDBACK_LOOP" => { + Ok(GuildFeatures::GuildRoleSubscriptionPurchaseFeedbackLoop) + } + "GUILD_ROLE_SUBSCRIPTION_TRIALS" => Ok(GuildFeatures::GuildRoleSubscriptionTrials), + "GUILD_SERVER_GUIDE" => Ok(GuildFeatures::GuildServerGuide), + "GUILD_WEB_PAGE_VANITY_URL" => Ok(GuildFeatures::GuildWebPageVanityURL), + "HAD_EARLY_ACTIVITIES_ACCESS" => Ok(GuildFeatures::HadEarlyActivitiesAccess), + "HAS_DIRECTORY_ENTRY" => Ok(GuildFeatures::HasDirectoryEntry), + "HIDE_FROM_EXPERIMENT_UI" => Ok(GuildFeatures::HideFromExperimentUi), + "HUB" => Ok(GuildFeatures::Hub), + "INCREASED_THREAD_LIMIT" => Ok(GuildFeatures::IncreasedThreadLimit), + "INTERNAL_EMPLOYEE_ONLY" => Ok(GuildFeatures::InternalEmployeeOnly), + "INVITE_SPLASH" => Ok(GuildFeatures::InviteSplash), + "INVITES_DISABLED" => Ok(GuildFeatures::InvitesDisabled), + "LINKED_TO_HUB" => Ok(GuildFeatures::LinkedToHub), + "MARKETPLACES_CONNECTION_ROLES" => Ok(GuildFeatures::MarketplacesConnectionRoles), + "MEMBER_PROFILES" => Ok(GuildFeatures::MemberProfiles), + "MEMBER_VERIFICATION_GATE_ENABLED" => Ok(GuildFeatures::MemberVerificationGateEnabled), + "MEMBER_VERIFICATION_MANUAL_APPROVAL" => { + Ok(GuildFeatures::MemberVerificationManualApproval) + } + "MOBILE_WEB_ROLE_SUBSCRIPTION_PURCHASE_PAGE" => { + Ok(GuildFeatures::MobileWebRoleSubscriptionPurchasePage) + } + "MONETIZATION_ENABLED" => Ok(GuildFeatures::MonetizationEnabled), + "MORE_EMOJI" => Ok(GuildFeatures::MoreEmoji), + "MORE_STICKERS" => Ok(GuildFeatures::MoreStickers), + "NEWS" => Ok(GuildFeatures::News), + "NEW_THREAD_PERMISSIONS" => Ok(GuildFeatures::NewThreadPermissions), + "PARTNERED" => Ok(GuildFeatures::Partnered), + "PREMIUM_TIER_3_OVERRIDE" => Ok(GuildFeatures::PremiumTier3Override), + "PREVIEW_ENABLED" => Ok(GuildFeatures::PreviewEnabled), + "RAID_ALERTS_DISABLED" => Ok(GuildFeatures::RaidAlertsDisabled), + "RELAY_ENABLED" => Ok(GuildFeatures::RelayEnabled), + "RESTRICT_SPAM_RISK_GUILD" => Ok(GuildFeatures::RestrictSpamRiskGuild), + "ROLE_ICONS" => Ok(GuildFeatures::RoleIcons), + "ROLE_SUBSCRIPTIONS_AVAILABLE_FOR_PURCHASE" => { + Ok(GuildFeatures::RoleSubscriptionsAvailableForPurchase) + } + "ROLE_SUBSCRIPTIONS_ENABLED" => Ok(GuildFeatures::RoleSubscriptionsEnabled), + "ROLE_SUBSCRIPTIONS_ENABLED_FOR_PURCHASE" => { + Ok(GuildFeatures::RoleSubscriptionsEnabledForPurchase) + } + "SHARD" => Ok(GuildFeatures::Shard), + "SHARED_CANVAS_FRIENDS_AND_FAMILY_TEST" => { + Ok(GuildFeatures::SharedCanvasFriendsAndFamilyTest) + } + "SOUNDBOARD" => Ok(GuildFeatures::Soundboard), + "SUMMARIES_ENABLED" => Ok(GuildFeatures::SummariesEnabled), + "SUMMARIES_ENABLED_GA" => Ok(GuildFeatures::SummariesEnabledGa), + "SUMMARIES_DISABLED_BY_USER" => Ok(GuildFeatures::SummariesDisabledByUser), + "SUMMARIES_ENABLED_BY_USER" => Ok(GuildFeatures::SummariesEnabledByUser), + "TEXT_IN_STAGE_ENABLED" => Ok(GuildFeatures::TextInStageEnabled), + "TEXT_IN_VOICE_ENABLED" => Ok(GuildFeatures::TextInVoiceEnabled), + "THREADS_ENABLED_TESTING" => Ok(GuildFeatures::ThreadsEnabledTesting), + "THREADS_ENABLED" => Ok(GuildFeatures::ThreadsEnabled), + "THREAD_DEFAULT_AUTO_ARCHIVE_DURATION" => { + Ok(GuildFeatures::ThreadDefaultAutoArchiveDuration) + } + "THREADS_ONLY_CHANNEL" => Ok(GuildFeatures::ThreadsOnlyChannel), + "TICKETED_EVENTS_ENABLED" => Ok(GuildFeatures::TicketedEventsEnabled), + "TICKETING_ENABLED" => Ok(GuildFeatures::TicketingEnabled), + "VANITY_URL" => Ok(GuildFeatures::VanityUrl), + "VERIFIED" => Ok(GuildFeatures::Verified), + "VIP_REGIONS" => Ok(GuildFeatures::VipRegions), + "VOICE_CHANNEL_EFFECTS" => Ok(GuildFeatures::VoiceChannelEffects), + "WELCOME_SCREEN_ENABLED" => Ok(GuildFeatures::WelcomeScreenEnabled), + "ALIASABLE_NAMES" => Ok(GuildFeatures::AliasableNames), + "ALLOW_INVALID_CHANNEL_NAME" => Ok(GuildFeatures::AllowInvalidChannelName), + "ALLOW_UNNAMED_CHANNELS" => Ok(GuildFeatures::AllowUnnamedChannels), + "CROSS_CHANNEL_REPLIES" => Ok(GuildFeatures::CrossChannelReplies), + "IRC_LIKE_CATEGORY_NAMES" => Ok(GuildFeatures::IrcLikeCategoryNames), + "INVITES_CLOSED" => Ok(GuildFeatures::InvitesClosed), + _ => Err(Error::Guild(GuildError::InvalidGuildFeature)), + } + } +} + +impl GuildFeatures { + pub fn to_str(&self) -> &'static str { + match *self { + GuildFeatures::ActivitiesAlpha => "ACTIVITIES_ALPHA", + GuildFeatures::ActivitiesEmployee => "ACTIVITIES_EMPLOYEE", + GuildFeatures::ActivitiesInternalDev => "ACTIVITIES_INTERNAL_DEV", + GuildFeatures::AnimatedBanner => "ANIMATED_BANNER", + GuildFeatures::AnimatedIcon => "ANIMATED_ICON", + GuildFeatures::ApplicationCommandPermissionsV2 => "APPLICATION_COMMAND_PERMISSIONS_V2", + GuildFeatures::AutoModeration => "AUTO_MODERATION", + GuildFeatures::AutoModTriggerKeywordFilter => "AUTO_MOD_TRIGGER_KEYWORD_FILTER", + GuildFeatures::AutoModTriggerMLSpamFilter => "AUTO_MOD_TRIGGER_ML_SPAM_FILTER", + GuildFeatures::AutoModTriggerSpamLinkFilter => "AUTO_MOD_TRIGGER_SPAM_LINK_FILTER", + GuildFeatures::AutoModTriggerUserProfile => "AUTO_MOD_TRIGGER_USER_PROFILE", + GuildFeatures::Banner => "BANNER", + GuildFeatures::Bfg => "BFG", + GuildFeatures::BoostingTiersExperimentMediumGuild => { + "BOOSTING_TIERS_EXPERIMENT_MEDIUM_GUILD" + } + GuildFeatures::BoostingTiersExperimentSmallGuild => { + "BOOSTING_TIERS_EXPERIMENT_SMALL_GUILD" + } + GuildFeatures::BotDeveloperEarlyAccess => "BOT_DEVELOPER_EARLY_ACCESS", + GuildFeatures::BurstReactions => "BURST_REACTIONS", + GuildFeatures::CommunityCanary => "COMMUNITY_CANARY", + GuildFeatures::CommunityExpLargeGated => "COMMUNITY_EXP_LARGE_GATED", + GuildFeatures::CommunityExpLargeUngated => "COMMUNITY_EXP_LARGE_UNGATED", + GuildFeatures::CommunityExpMedium => "COMMUNITY_EXP_MEDIUM", + GuildFeatures::ChannelEmojisGenerated => "CHANNEL_EMOJIS_GENERATED", + GuildFeatures::ChannelHighlights => "CHANNEL_HIGHLIGHTS", + GuildFeatures::ChannelHighlightsDisabled => "CHANNEL_HIGHLIGHTS_DISABLED", + GuildFeatures::ClydeEnabled => "CLYDE_ENABLED", + GuildFeatures::ClydeExperimentEnabled => "CLYDE_EXPERIMENT_ENABLED", + GuildFeatures::ClydeDisabled => "CLYDE_DISABLED", + GuildFeatures::Community => "COMMUNITY", + GuildFeatures::CreatorAcceptedNewTerms => "CREATOR_ACCEPTED_NEW_TERMS", + GuildFeatures::CreatorMonetizable => "CREATOR_MONETIZABLE", + GuildFeatures::CreatorMonetizableDisabled => "CREATOR_MONETIZABLE_DISABLED", + GuildFeatures::CreatorMonetizablePendingNewOwnerOnboarding => { + "CREATOR_MONETIZABLE_PENDING_NEW_OWNER_ONBOARDING" + } + GuildFeatures::CreatorMonetizableProvisional => "CREATOR_MONETIZABLE_PROVISIONAL", + GuildFeatures::CreatorMonetizableRestricted => "CREATOR_MONETIZABLE_RESTRICTED", + GuildFeatures::CreatorMonetizableWhiteglove => "CREATOR_MONETIZABLE_WHITEGLOVE", + GuildFeatures::CreatorMonetizableApplicationAllowlist => { + "CREATOR_MONETIZABLE_APPLICATION_ALLOWLIST" + } + GuildFeatures::CreateStorePage => "CREATE_STORE_PAGE", + GuildFeatures::DeveloperSupportServer => "DEVELOPER_SUPPORT_SERVER", + GuildFeatures::DiscoverableDisabled => "DISCOVERABLE_DISABLED", + GuildFeatures::Discoverable => "DISCOVERABLE", + GuildFeatures::EnabledDiscoverableBefore => "ENABLED_DISCOVERABLE_BEFORE", + GuildFeatures::ExposedToActivitiesWTPExperiment => { + "EXPOSED_TO_ACTIVITIES_WTP_EXPERIMENT" + } + GuildFeatures::GuestsEnabled => "GUESTS_ENABLED", + GuildFeatures::GuildAutomodDefaultList => "GUILD_AUTOMOD_DEFAULT_LIST", + GuildFeatures::GuildCommunicationDisabledGuilds => { + "GUILD_COMMUNICATION_DISABLED_GUILDS" + } + GuildFeatures::GuildHomeDeprecationOverride => "GUILD_HOME_DEPRECATION_OVERRIDE", + GuildFeatures::GuildHomeOverride => "GUILD_HOME_OVERRIDE", + GuildFeatures::GuildHomeTest => "GUILD_HOME_TEST", + GuildFeatures::GuildMemberVerificationExperiment => { + "GUILD_MEMBER_VERIFICATION_EXPERIMENT" + } + GuildFeatures::GuildOnboarding => "GUILD_ONBOARDING", + GuildFeatures::GuildOnboardingAdminOnly => "GUILD_ONBOARDING_ADMIN_ONLY", + GuildFeatures::GuildOnboardingEverEnabled => "GUILD_ONBOARDING_EVER_ENABLED", + GuildFeatures::GuildOnboardingHasPrompts => "GUILD_ONBOARDING_HAS_PROMPTS", + GuildFeatures::GuildRoleSubscription => "GUILD_ROLE_SUBSCRIPTION", + GuildFeatures::GuildRoleSubscriptionPurchaseFeedbackLoop => { + "GUILD_ROLE_SUBSCRIPTION_PURCHASE_FEEDBACK_LOOP" + } + GuildFeatures::GuildRoleSubscriptionTrials => "GUILD_ROLE_SUBSCRIPTION_TRIALS", + GuildFeatures::GuildServerGuide => "GUILD_SERVER_GUIDE", + GuildFeatures::GuildWebPageVanityURL => "GUILD_WEB_PAGE_VANITY_URL", + GuildFeatures::HadEarlyActivitiesAccess => "HAD_EARLY_ACTIVITIES_ACCESS", + GuildFeatures::HasDirectoryEntry => "HAS_DIRECTORY_ENTRY", + GuildFeatures::HideFromExperimentUi => "HIDE_FROM_EXPERIMENT_UI", + GuildFeatures::Hub => "HUB", + GuildFeatures::IncreasedThreadLimit => "INCREASED_THREAD_LIMIT", + GuildFeatures::InternalEmployeeOnly => "INTERNAL_EMPLOYEE_ONLY", + GuildFeatures::InviteSplash => "INVITE_SPLASH", + GuildFeatures::InvitesDisabled => "INVITES_DISABLED", + GuildFeatures::LinkedToHub => "LINKED_TO_HUB", + GuildFeatures::MarketplacesConnectionRoles => "MARKETPLACES_CONNECTION_ROLES", + GuildFeatures::MemberProfiles => "MEMBER_PROFILES", + GuildFeatures::MemberVerificationGateEnabled => "MEMBER_VERIFICATION_GATE_ENABLED", + GuildFeatures::MemberVerificationManualApproval => { + "MEMBER_VERIFICATION_MANUAL_APPROVAL" + } + GuildFeatures::MobileWebRoleSubscriptionPurchasePage => { + "MOBILE_WEB_ROLE_SUBSCRIPTION_PURCHASE_PAGE" + } + GuildFeatures::MonetizationEnabled => "MONETIZATION_ENABLED", + GuildFeatures::MoreEmoji => "MORE_EMOJI", + GuildFeatures::MoreStickers => "MORE_STICKERS", + GuildFeatures::News => "NEWS", + GuildFeatures::NewThreadPermissions => "NEW_THREAD_PERMISSIONS", + GuildFeatures::Partnered => "PARTNERED", + GuildFeatures::PremiumTier3Override => "PREMIUM_TIER_3_OVERRIDE", + GuildFeatures::PreviewEnabled => "PREVIEW_ENABLED", + GuildFeatures::RaidAlertsDisabled => "RAID_ALERTS_DISABLED", + GuildFeatures::RelayEnabled => "RELAY_ENABLED", + GuildFeatures::RestrictSpamRiskGuild => "RESTRICT_SPAM_RISK_GUILD", + GuildFeatures::RoleIcons => "ROLE_ICONS", + GuildFeatures::RoleSubscriptionsAvailableForPurchase => { + "ROLE_SUBSCRIPTIONS_AVAILABLE_FOR_PURCHASE" + } + GuildFeatures::RoleSubscriptionsEnabled => "ROLE_SUBSCRIPTIONS_ENABLED", + GuildFeatures::RoleSubscriptionsEnabledForPurchase => { + "ROLE_SUBSCRIPTIONS_ENABLED_FOR_PURCHASE" + } + GuildFeatures::Shard => "SHARD", + GuildFeatures::SharedCanvasFriendsAndFamilyTest => { + "SHARED_CANVAS_FRIENDS_AND_FAMILY_TEST" + } + GuildFeatures::Soundboard => "SOUNDBOARD", + GuildFeatures::SummariesEnabled => "SUMMARIES_ENABLED", + GuildFeatures::SummariesEnabledGa => "SUMMARIES_ENABLED_GA", + GuildFeatures::SummariesDisabledByUser => "SUMMARIES_DISABLED_BY_USER", + GuildFeatures::SummariesEnabledByUser => "SUMMARIES_ENABLED_BY_USER", + GuildFeatures::TextInStageEnabled => "TEXT_IN_STAGE_ENABLED", + GuildFeatures::TextInVoiceEnabled => "TEXT_IN_VOICE_ENABLED", + GuildFeatures::ThreadsEnabledTesting => "THREADS_ENABLED_TESTING", + GuildFeatures::ThreadsEnabled => "THREADS_ENABLED", + GuildFeatures::ThreadDefaultAutoArchiveDuration => { + "THREAD_DEFAULT_AUTO_ARCHIVE_DURATION" + } + GuildFeatures::ThreadsOnlyChannel => "THREADS_ONLY_CHANNEL", + GuildFeatures::TicketedEventsEnabled => "TICKETED_EVENTS_ENABLED", + GuildFeatures::TicketingEnabled => "TICKETING_ENABLED", + GuildFeatures::VanityUrl => "VANITY_URL", + GuildFeatures::Verified => "VERIFIED", + GuildFeatures::VipRegions => "VIP_REGIONS", + GuildFeatures::VoiceChannelEffects => "VOICE_CHANNEL_EFFECTS", + GuildFeatures::WelcomeScreenEnabled => "WELCOME_SCREEN_ENABLED", + GuildFeatures::AliasableNames => "ALIASABLE_NAMES", + GuildFeatures::AllowInvalidChannelName => "ALLOW_INVALID_CHANNEL_NAME", + GuildFeatures::AllowUnnamedChannels => "ALLOW_UNNAMED_CHANNELS", + GuildFeatures::CrossChannelReplies => "CROSS_CHANNEL_REPLIES", + GuildFeatures::IrcLikeCategoryNames => "IRC_LIKE_CATEGORY_NAMES", + GuildFeatures::InvitesClosed => "INVITES_CLOSED", + } + } } #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] diff --git a/src/types/entities/guild.rs b/src/types/entities/guild.rs index f3f325b..a5329fc 100644 --- a/src/types/entities/guild.rs +++ b/src/types/entities/guild.rs @@ -2,6 +2,7 @@ use chrono::{DateTime, Utc}; use serde::{Deserialize, Serialize}; use serde_repr::{Deserialize_repr, Serialize_repr}; +use crate::types::types::guild_configuration::GuildFeaturesList; use crate::types::{ entities::{Channel, Emoji, RoleObject, Sticker, User, VoiceState, Webhook}, interfaces::WelcomeScreenObject, @@ -35,8 +36,9 @@ pub struct Guild { pub roles: Vec, #[cfg_attr(feature = "sqlx", sqlx(skip))] pub emojis: Vec, + //#[cfg_attr(feature = "sqlx", sqlx(try_from = "String"))] + pub features: GuildFeaturesList, #[cfg_attr(feature = "sqlx", sqlx(skip))] - pub features: Option>, pub application_id: Option, pub system_channel_id: Option, pub system_channel_flags: Option, diff --git a/src/types/errors.rs b/src/types/errors.rs index a66b192..db7cbf7 100644 --- a/src/types/errors.rs +++ b/src/types/errors.rs @@ -14,6 +14,15 @@ pub enum Error { #[error(transparent)] FieldFormat(#[from] FieldFormatError), + + #[error(transparent)] + Guild(#[from] GuildError), +} + +#[derive(Debug, PartialEq, Eq, thiserror::Error)] +pub enum GuildError { + #[error("Invalid Guild Feature")] + InvalidGuildFeature, } #[derive(Debug, PartialEq, Eq, thiserror::Error)] From de10ccbed7a06deb37c4ee5fbfed398db9d38303 Mon Sep 17 00:00:00 2001 From: Zertex Date: Sun, 28 May 2023 02:42:35 -0400 Subject: [PATCH 06/42] Hijack this to make User::flags pub --- src/types/entities/user.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/types/entities/user.rs b/src/types/entities/user.rs index 7b1943e..4e92d6c 100644 --- a/src/types/entities/user.rs +++ b/src/types/entities/user.rs @@ -36,7 +36,7 @@ pub struct User { /// So we need to account for that #[serde(default)] #[serde(deserialize_with = "deserialize_option_number_from_string")] - flags: Option, + pub flags: Option, pub premium_since: Option>, pub premium_type: u8, pub pronouns: Option, From 268da9525cf8c6a1ba1a00603d114de44e406d50 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Sun, 28 May 2023 22:39:25 +0200 Subject: [PATCH 07/42] Add channel delete method --- src/api/channels/channels.rs | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/src/api/channels/channels.rs b/src/api/channels/channels.rs index aba4725..12df44e 100644 --- a/src/api/channels/channels.rs +++ b/src/api/channels/channels.rs @@ -38,4 +38,29 @@ impl Channel { }), } } + + pub async fn delete( + token: &str, + url_api: &str, + channel_id: &str, + limits_user: &mut Limits, + limits_instance: &mut Limits, + ) -> Option { + let request = Client::new() + .delete(format!("{}/channels/{}/", url_api, channel_id)) + .bearer_auth(token); + match LimitedRequester::new() + .await + .send_request( + request, + crate::api::limits::LimitType::Channel, + limits_instance, + limits_user, + ) + .await + { + Ok(_) => None, + Err(e) => return Some(e), + } + } } From 69b6efe200d26b118c2eb44d51801a59148248dd Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Sun, 28 May 2023 22:39:38 +0200 Subject: [PATCH 08/42] Make channel delete take ownership of a Channel --- src/api/channels/channels.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/api/channels/channels.rs b/src/api/channels/channels.rs index 12df44e..2e0a3ff 100644 --- a/src/api/channels/channels.rs +++ b/src/api/channels/channels.rs @@ -42,12 +42,12 @@ impl Channel { pub async fn delete( token: &str, url_api: &str, - channel_id: &str, + channel: Channel, limits_user: &mut Limits, limits_instance: &mut Limits, ) -> Option { let request = Client::new() - .delete(format!("{}/channels/{}/", url_api, channel_id)) + .delete(format!("{}/channels/{}/", url_api, channel.id.to_string())) .bearer_auth(token); match LimitedRequester::new() .await From 2ba1e1ac8421bc4ff99d39b647fdfbaa5bfd2d99 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Sun, 28 May 2023 22:40:37 +0200 Subject: [PATCH 09/42] Add documentation --- src/api/channels/channels.rs | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/src/api/channels/channels.rs b/src/api/channels/channels.rs index 2e0a3ff..6a23578 100644 --- a/src/api/channels/channels.rs +++ b/src/api/channels/channels.rs @@ -39,6 +39,19 @@ impl Channel { } } + /// Deletes a channel. + /// + /// # Arguments + /// + /// * `token` - A string slice that holds the authorization token. + /// * `url_api` - A string slice that holds the URL of the API. + /// * `channel` - A `Channel` object that represents the channel to be deleted. + /// * `limits_user` - A mutable reference to a `Limits` object that represents the user's rate limits. + /// * `limits_instance` - A mutable reference to a `Limits` object that represents the instance's rate limits. + /// + /// # Returns + /// + /// An `Option` that contains an `InstanceServerError` if an error occurred during the request, or `None` if the request was successful. pub async fn delete( token: &str, url_api: &str, From 5db5a2562f944e0f7b79fe903322cffeafb73710 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Sun, 28 May 2023 23:04:02 +0200 Subject: [PATCH 10/42] Add InvalidResponseError --- src/errors.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/errors.rs b/src/errors.rs index f76b029..749c8f7 100644 --- a/src/errors.rs +++ b/src/errors.rs @@ -23,6 +23,7 @@ custom_error! { NoPermission = "You do not have the permissions needed to perform this action.", NotFound{error: String} = "The provided resource hasn't been found: {}", PasswordRequiredError = "You need to provide your current password to authenticate for this action.", + InvalidResponseError{error: String} = "The response is malformed and cannot be processed. Error: {}", } custom_error! { From 897c269e9866f6f98ababee7bb219bbf5c32ff1e Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Sun, 28 May 2023 23:04:13 +0200 Subject: [PATCH 11/42] Make delete use self --- src/api/channels/channels.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/api/channels/channels.rs b/src/api/channels/channels.rs index 6a23578..4fd217d 100644 --- a/src/api/channels/channels.rs +++ b/src/api/channels/channels.rs @@ -53,14 +53,14 @@ impl Channel { /// /// An `Option` that contains an `InstanceServerError` if an error occurred during the request, or `None` if the request was successful. pub async fn delete( + self, token: &str, url_api: &str, - channel: Channel, limits_user: &mut Limits, limits_instance: &mut Limits, ) -> Option { let request = Client::new() - .delete(format!("{}/channels/{}/", url_api, channel.id.to_string())) + .delete(format!("{}/channels/{}/", url_api, self.id.to_string())) .bearer_auth(token); match LimitedRequester::new() .await From 7b7dbb9b5e832aa9b9b06b8f47158fa2ed1012b1 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Sun, 28 May 2023 23:04:35 +0200 Subject: [PATCH 12/42] Create channels() for Guild This method retrieves all channels from a guild --- src/api/guilds/guilds.rs | 54 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/src/api/guilds/guilds.rs b/src/api/guilds/guilds.rs index d1f03f0..6a5092f 100644 --- a/src/api/guilds/guilds.rs +++ b/src/api/guilds/guilds.rs @@ -148,6 +148,60 @@ impl Guild { ) .await } + + /// Returns a `Result` containing a vector of `Channel` structs if the request was successful, or an `InstanceServerError` if there was an error. + /// + /// # Arguments + /// + /// * `url_api` - A string slice that holds the URL of the API. + /// * `token` - A string slice that holds the authorization token. + /// * `limits_user` - A mutable reference to a `Limits` struct containing the user's rate limits. + /// * `limits_instance` - A mutable reference to a `Limits` struct containing the instance's rate limits. + /// + pub async fn channels( + &self, + url_api: &str, + token: &str, + limits_user: &mut Limits, + limits_instance: &mut Limits, + ) -> Result, InstanceServerError> { + let request = Client::new() + .get(format!( + "{}/guilds/{}/channels/", + url_api, + self.id.to_string() + )) + .bearer_auth(token); + let result = match LimitedRequester::new() + .await + .send_request( + request, + crate::api::limits::LimitType::Guild, + limits_instance, + limits_user, + ) + .await + { + Ok(result) => result, + Err(e) => return Err(e), + }; + let stringed_response = match result.text().await { + Ok(value) => value, + Err(e) => { + return Err(InstanceServerError::InvalidResponseError { + error: e.to_string(), + }) + } + }; + let _: Vec = match from_str(&stringed_response) { + Ok(result) => return Ok(result), + Err(e) => { + return Err(InstanceServerError::InvalidResponseError { + error: e.to_string(), + }) + } + }; + } } impl Channel { From 7f6ed720680dc4156794b9b60d499865a8815e5c Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Sun, 28 May 2023 23:04:56 +0200 Subject: [PATCH 13/42] Add delete_channel test. --- tests/channel.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/tests/channel.rs b/tests/channel.rs index 4e0db28..a162d41 100644 --- a/tests/channel.rs +++ b/tests/channel.rs @@ -21,3 +21,18 @@ async fn get_channel() { ); common::teardown(bundle).await } + +#[tokio::test] +async fn delete_channel() { + let mut bundle = common::setup().await; + let result = bundle + .channel + .delete( + &bundle.user.token, + bundle.instance.urls.get_api(), + &mut bundle.user.limits, + &mut bundle.instance.limits, + ) + .await; + assert!(result.is_none()); +} From 135782da9f92b1af454fd1f37e62b405c38b0025 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Sun, 28 May 2023 23:08:05 +0200 Subject: [PATCH 14/42] Remove print statement --- src/api/auth/register.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/api/auth/register.rs b/src/api/auth/register.rs index d318916..2c8f3f9 100644 --- a/src/api/auth/register.rs +++ b/src/api/auth/register.rs @@ -48,7 +48,6 @@ pub mod register { let response_unwrap = response.unwrap(); let status = response_unwrap.status(); let response_unwrap_text = response_unwrap.text().await.unwrap(); - println!("{}", response_unwrap_text); let token = from_str::(&response_unwrap_text).unwrap(); let token = token.token; if status.is_client_error() { From b2b5930db0cb6c35c13e5e092ae2e35b5f3c08fe Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Sun, 28 May 2023 23:08:13 +0200 Subject: [PATCH 15/42] Remove print statement --- src/api/channels/messages.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/api/channels/messages.rs b/src/api/channels/messages.rs index 91e148a..7b43eef 100644 --- a/src/api/channels/messages.rs +++ b/src/api/channels/messages.rs @@ -78,8 +78,6 @@ pub mod messages { .bearer_auth(token) .multipart(form); - println!("[Request Headers: ] {:?}", message_request); - requester .send_request( message_request, From fee0aa966a611da2d06f1de801606a9305dabd5f Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 16:49:36 +0200 Subject: [PATCH 16/42] Changed some apparently incorrect attributes Some attributes are not necessarily returned by the GET route for a guild. Also, some integers were too small. One example is max_video_channel_users, which was a u8, but could theoretically be a value much higher than u8::MAX. --- src/types/entities/guild.rs | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/types/entities/guild.rs b/src/types/entities/guild.rs index 3a6b11a..9ce09ac 100644 --- a/src/types/entities/guild.rs +++ b/src/types/entities/guild.rs @@ -19,25 +19,25 @@ pub struct Guild { pub splash: Option, pub discovery_splash: Option, #[cfg_attr(feature = "sqlx", sqlx(skip))] - pub owner: bool, // True if requesting user is owner + pub owner: Option, // True if requesting user is owner pub owner_id: Option, pub permissions: Option, pub afk_channel_id: Option, - pub afk_timeout: Option, + pub afk_timeout: Option, pub widget_enabled: Option, pub widget_channel_id: Option, pub verification_level: Option, pub default_message_notifications: Option, pub explicit_content_filter: Option, #[cfg_attr(feature = "sqlx", sqlx(skip))] - pub roles: Vec, + pub roles: Option>, #[cfg_attr(feature = "sqlx", sqlx(skip))] - pub emojis: Vec, + pub emojis: Option>, #[cfg_attr(feature = "sqlx", sqlx(skip))] pub features: Option>, pub application_id: Option, pub system_channel_id: Option, - pub system_channel_flags: Option, + pub system_channel_flags: Option, pub rules_channel_id: Option, pub rules_channel: Option, pub max_presences: Option, @@ -49,8 +49,8 @@ pub struct Guild { pub premium_subscription_count: Option, pub preferred_locale: Option, pub public_updates_channel_id: Option, - pub max_video_channel_users: Option, - pub max_stage_video_channel_users: Option, + pub max_video_channel_users: Option, + pub max_stage_video_channel_users: Option, pub approximate_member_count: Option, pub approximate_presence_count: Option, #[cfg(feature = "sqlx")] @@ -62,7 +62,7 @@ pub struct Guild { pub stickers: Option>, pub premium_progress_bar_enabled: Option, #[cfg_attr(feature = "sqlx", sqlx(skip))] - pub joined_at: String, + pub joined_at: Option, #[cfg_attr(feature = "sqlx", sqlx(skip))] pub bans: Option>, pub primary_category_id: Option, From 7f8abceab53ded636c5855bbc2e81c0979e66557 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 16:50:10 +0200 Subject: [PATCH 17/42] Made Guild::create return Guild instead of String. This makes way more sense, I think. --- src/api/guilds/guilds.rs | 70 +++++++++++++++++++++++++++++----------- 1 file changed, 52 insertions(+), 18 deletions(-) diff --git a/src/api/guilds/guilds.rs b/src/api/guilds/guilds.rs index 6a5092f..45482b3 100644 --- a/src/api/guilds/guilds.rs +++ b/src/api/guilds/guilds.rs @@ -19,32 +19,20 @@ impl Guild { /// /// # Returns /// - /// A `Result` containing the ID of the newly created guild, or an error if the request fails. + /// A `Result` containing the object of the newly created guild, or an error if the request fails. /// /// # Errors /// /// Returns an `InstanceServerError` if the request fails. /// - /// # Examples - /// - /// ```rs - /// let guild_create_schema = chorus::api::schemas::GuildCreateSchema::new(insert args here); - /// - /// let result = Guild::create(&mut user, &mut instance, &guild_create_schema).await; - /// - /// match result { - /// Ok(guild_id) => println!("Created guild with ID {}", guild_id), - /// Err(e) => println!("Failed to create guild: {}", e), - /// } - /// ``` pub async fn create( user: &mut UserMeta, url_api: &str, guild_create_schema: GuildCreateSchema, - ) -> Result { + ) -> Result { let url = format!("{}/guilds/", url_api); - let limits_user = user.limits.get_as_mut(); - let limits_instance = &mut user.belongs_to.borrow_mut().limits; + let mut limits_user = user.limits.get_as_mut(); + let mut limits_instance = &mut user.belongs_to.borrow_mut().limits; let request = reqwest::Client::new() .post(url.clone()) .bearer_auth(user.token.clone()) @@ -63,7 +51,16 @@ impl Guild { Err(e) => return Err(e), }; let id: GuildCreateResponse = from_str(&result.text().await.unwrap()).unwrap(); - Ok(id.id) + let guild = Guild::get( + url_api, + &id.id, + &user.token, + &mut limits_user, + &mut limits_instance, + ) + .await + .unwrap(); + Ok(guild) } /// Deletes a guild. @@ -93,7 +90,7 @@ impl Guild { pub async fn delete( user: &mut UserMeta, url_api: &str, - guild_id: String, + guild_id: &str, ) -> Option { let url = format!("{}/guilds/{}/delete/", url_api, guild_id); let limits_user = user.limits.get_as_mut(); @@ -202,6 +199,43 @@ impl Guild { } }; } + + /// Returns a `Result` containing a `Guild` struct if the request was successful, or an `InstanceServerError` if there was an error. + /// + /// # Arguments + /// + /// * `url_api` - A string slice that holds the URL of the API. + /// * `guild_id` - A string slice that holds the ID of the guild. + /// * `token` - A string slice that holds the authorization token. + /// * `limits_user` - A mutable reference to a `Limits` struct containing the user's rate limits. + /// * `limits_instance` - A mutable reference to a `Limits` struct containing the instance's rate limits. + /// + pub async fn get( + url_api: &str, + guild_id: &str, + token: &str, + limits_user: &mut Limits, + limits_instance: &mut Limits, + ) -> Result { + let request = Client::new() + .get(format!("{}/guilds/{}/", url_api, guild_id)) + .bearer_auth(token); + let response = match LimitedRequester::new() + .await + .send_request( + request, + crate::api::limits::LimitType::Guild, + limits_instance, + limits_user, + ) + .await + { + Ok(response) => response, + Err(e) => return Err(e), + }; + let guild: Guild = from_str(&response.text().await.unwrap()).unwrap(); + Ok(guild) + } } impl Channel { From d51291de3c020b3e3d18c411be6288aa730d414e Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 16:51:28 +0200 Subject: [PATCH 18/42] Change test delete, add test get_channels() --- tests/guild.rs | 29 ++++++++++++++++++++++++++--- 1 file changed, 26 insertions(+), 3 deletions(-) diff --git a/tests/guild.rs b/tests/guild.rs index 6b50a94..48794d8 100644 --- a/tests/guild.rs +++ b/tests/guild.rs @@ -19,11 +19,34 @@ async fn guild_creation_deletion() { .await .unwrap(); - println!("{}", guild); - - match Guild::delete(&mut bundle.user, bundle.urls.get_api(), guild).await { + match Guild::delete( + &mut bundle.user, + bundle.urls.get_api(), + &guild.id.to_string(), + ) + .await + { None => assert!(true), Some(_) => assert!(false), } common::teardown(bundle).await } + +#[tokio::test] +async fn get_channels() { + let mut bundle = common::setup().await; + println!( + "{:?}", + bundle + .guild + .channels( + bundle.instance.urls.get_api(), + &bundle.user.token, + &mut bundle.user.limits, + &mut bundle.instance.limits, + ) + .await + .unwrap() + ); + common::teardown(bundle).await; +} From 789d7ec7e8132c75d97a8afb7918db2e9d8431da Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 16:51:41 +0200 Subject: [PATCH 19/42] Replace guild_id with guild object --- tests/common/mod.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/common/mod.rs b/tests/common/mod.rs index 3fdb42b..61fb2fc 100644 --- a/tests/common/mod.rs +++ b/tests/common/mod.rs @@ -9,7 +9,7 @@ pub struct TestBundle { pub urls: URLBundle, pub user: UserMeta, pub instance: Instance, - pub guild_id: String, + pub guild: Guild, pub channel: Channel, } @@ -65,13 +65,13 @@ pub async fn setup() -> TestBundle { video_quality_mode: None, }; let mut user = instance.register_account(®).await.unwrap(); - let guild_id = Guild::create(&mut user, urls.get_api(), guild_create_schema) + let guild = Guild::create(&mut user, urls.get_api(), guild_create_schema) .await .unwrap(); let channel = Channel::create( &user.token, urls.get_api(), - guild_id.as_str(), + &guild.id.to_string(), channel_create_schema, &mut user.limits, &mut instance.limits, @@ -83,7 +83,7 @@ pub async fn setup() -> TestBundle { urls, user, instance, - guild_id, + guild, channel, } } @@ -93,7 +93,7 @@ pub async fn teardown(mut bundle: TestBundle) { Guild::delete( &mut bundle.user, bundle.instance.urls.get_api(), - bundle.guild_id, + &bundle.guild.id.to_string(), ) .await; bundle.user.delete().await; From 5a40da1cd67bc1454efcfcf25818bb85b7729ce0 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 17:25:34 +0200 Subject: [PATCH 20/42] Implement User methods on User instead of UserMeta --- src/api/users/users.rs | 101 ++++++++++++++++++++++++----------------- 1 file changed, 60 insertions(+), 41 deletions(-) diff --git a/src/api/users/users.rs b/src/api/users/users.rs index 098a92f..dacff1f 100644 --- a/src/api/users/users.rs +++ b/src/api/users/users.rs @@ -26,30 +26,7 @@ impl UserMeta { id: Option<&String>, instance_limits: &mut Limits, ) -> Result { - let url: String; - if id.is_none() { - url = format!("{}/users/@me/", url_api); - } else { - url = format!("{}/users/{}", url_api, id.unwrap()); - } - let request = reqwest::Client::new().get(url).bearer_auth(token); - let mut requester = crate::limit::LimitedRequester::new().await; - let mut cloned_limits = instance_limits.clone(); - match requester - .send_request( - request, - crate::api::limits::LimitType::Ip, - instance_limits, - &mut cloned_limits, - ) - .await - { - Ok(result) => { - let result_text = result.text().await.unwrap(); - Ok(serde_json::from_str::(&result_text).unwrap()) - } - Err(e) => Err(e), - } + User::get(token, url_api, id, instance_limits).await } pub async fn get_settings( @@ -57,23 +34,7 @@ impl UserMeta { url_api: &String, instance_limits: &mut Limits, ) -> Result { - let request: reqwest::RequestBuilder = Client::new() - .get(format!("{}/users/@me/settings/", url_api)) - .bearer_auth(token); - let mut cloned_limits = instance_limits.clone(); - let mut requester = crate::limit::LimitedRequester::new().await; - match requester - .send_request( - request, - crate::api::limits::LimitType::Ip, - instance_limits, - &mut cloned_limits, - ) - .await - { - Ok(result) => Ok(serde_json::from_str(&result.text().await.unwrap()).unwrap()), - Err(e) => Err(e), - } + User::get_settings(token, url_api, instance_limits).await } /// Modify the current user's `UserObject`. @@ -153,6 +114,64 @@ impl UserMeta { } } +impl User { + pub async fn get( + token: &String, + url_api: &String, + id: Option<&String>, + instance_limits: &mut Limits, + ) -> Result { + let url: String; + if id.is_none() { + url = format!("{}/users/@me/", url_api); + } else { + url = format!("{}/users/{}", url_api, id.unwrap()); + } + let request = reqwest::Client::new().get(url).bearer_auth(token); + let mut requester = crate::limit::LimitedRequester::new().await; + let mut cloned_limits = instance_limits.clone(); + match requester + .send_request( + request, + crate::api::limits::LimitType::Ip, + instance_limits, + &mut cloned_limits, + ) + .await + { + Ok(result) => { + let result_text = result.text().await.unwrap(); + Ok(serde_json::from_str::(&result_text).unwrap()) + } + Err(e) => Err(e), + } + } + + pub async fn get_settings( + token: &String, + url_api: &String, + instance_limits: &mut Limits, + ) -> Result { + let request: reqwest::RequestBuilder = Client::new() + .get(format!("{}/users/@me/settings/", url_api)) + .bearer_auth(token); + let mut cloned_limits = instance_limits.clone(); + let mut requester = crate::limit::LimitedRequester::new().await; + match requester + .send_request( + request, + crate::api::limits::LimitType::Ip, + instance_limits, + &mut cloned_limits, + ) + .await + { + Ok(result) => Ok(serde_json::from_str(&result.text().await.unwrap()).unwrap()), + Err(e) => Err(e), + } + } +} + impl Instance { /** Get a user object by id, or get the current user. From 0048e548f572f40c82bd555ef42f22a6e2c9220a Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 18:27:15 +0200 Subject: [PATCH 21/42] Add ChannelModifySchema --- src/types/schema/channel.rs | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/src/types/schema/channel.rs b/src/types/schema/channel.rs index 458c33c..6cc16ab 100644 --- a/src/types/schema/channel.rs +++ b/src/types/schema/channel.rs @@ -25,3 +25,26 @@ pub struct ChannelCreateSchema { pub default_thread_rate_limit_per_user: Option, pub video_quality_mode: Option, } + +#[derive(Debug, Deserialize, Serialize)] +#[serde(rename_all = "snake_case")] +pub struct ChannelModifySchema { + name: Option, + channel_type: Option, + topic: Option, + icon: Option, + bitrate: Option, + user_limit: Option, + rate_limit_per_user: Option, + position: Option, + permission_overwrites: Option>, + parent_id: Option, + id: Option, + nsfw: Option, + rtc_region: Option, + default_auto_archive_duration: Option, + default_reaction_emoji: Option, + flags: Option, + default_thread_rate_limit_per_user: Option, + video_quality_mode: Option, +} From 05bc4a4647b40cbc7780346292ea9f8e93d9fdeb Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 18:27:30 +0200 Subject: [PATCH 22/42] Add modify() --- src/api/channels/channels.rs | 49 ++++++++++++++++++++++++++++++++++-- 1 file changed, 47 insertions(+), 2 deletions(-) diff --git a/src/api/channels/channels.rs b/src/api/channels/channels.rs index 4fd217d..bfe9959 100644 --- a/src/api/channels/channels.rs +++ b/src/api/channels/channels.rs @@ -1,8 +1,11 @@ use reqwest::Client; -use serde_json::from_str; +use serde_json::{from_str, to_string}; use crate::{ - api::limits::Limits, errors::InstanceServerError, limit::LimitedRequester, types::Channel, + api::limits::Limits, + errors::InstanceServerError, + limit::LimitedRequester, + types::{Channel, ChannelModifySchema}, }; impl Channel { @@ -76,4 +79,46 @@ impl Channel { Err(e) => return Some(e), } } + + /// Modifies a channel. + /// + /// # Arguments + /// + /// * `modify_data` - A `ChannelModifySchema` object that represents the modifications to be made to the channel. + /// * `token` - A string slice that holds the authorization token. + /// * `url_api` - A string slice that holds the URL of the API. + /// * `channel_id` - A string slice that holds the ID of the channel to be modified. + /// * `limits_user` - A mutable reference to a `Limits` object that represents the user's rate limits. + /// * `limits_instance` - A mutable reference to a `Limits` object that represents the instance's rate limits. + /// + /// # Returns + /// + /// A `Result` that contains a `Channel` object if the request was successful, or an `InstanceServerError` if an error occurred during the request. + pub async fn modify( + modify_data: ChannelModifySchema, + token: &str, + url_api: &str, + channel_id: &str, + limits_user: &mut Limits, + limits_instance: &mut Limits, + ) -> Result { + let request = Client::new() + .patch(format!("{}/channels/{}/", url_api, channel_id)) + .bearer_auth(token) + .body(to_string(&modify_data).unwrap()); + let channel = match LimitedRequester::new() + .await + .send_request( + request, + crate::api::limits::LimitType::Channel, + limits_instance, + limits_user, + ) + .await + { + Ok(channel) => from_str::(&channel.text().await.unwrap()).unwrap(), + Err(e) => return Err(e), + }; + Ok(channel) + } } From 6bcbb0e470c1cb26cf68155355cc35104a7b027f Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 18:29:08 +0200 Subject: [PATCH 23/42] Teardown after delete_channel --- tests/channel.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/channel.rs b/tests/channel.rs index a162d41..03e570f 100644 --- a/tests/channel.rs +++ b/tests/channel.rs @@ -27,6 +27,7 @@ async fn delete_channel() { let mut bundle = common::setup().await; let result = bundle .channel + .clone() .delete( &bundle.user.token, bundle.instance.urls.get_api(), @@ -35,4 +36,5 @@ async fn delete_channel() { ) .await; assert!(result.is_none()); + common::teardown(bundle).await } From a7fd29c7f120e4309ba7e2cdf92589fc59156a23 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 18:34:08 +0200 Subject: [PATCH 24/42] Make all attributes pub --- src/types/schema/channel.rs | 35 +++++++++++++++++------------------ 1 file changed, 17 insertions(+), 18 deletions(-) diff --git a/src/types/schema/channel.rs b/src/types/schema/channel.rs index 6cc16ab..67d9823 100644 --- a/src/types/schema/channel.rs +++ b/src/types/schema/channel.rs @@ -29,22 +29,21 @@ pub struct ChannelCreateSchema { #[derive(Debug, Deserialize, Serialize)] #[serde(rename_all = "snake_case")] pub struct ChannelModifySchema { - name: Option, - channel_type: Option, - topic: Option, - icon: Option, - bitrate: Option, - user_limit: Option, - rate_limit_per_user: Option, - position: Option, - permission_overwrites: Option>, - parent_id: Option, - id: Option, - nsfw: Option, - rtc_region: Option, - default_auto_archive_duration: Option, - default_reaction_emoji: Option, - flags: Option, - default_thread_rate_limit_per_user: Option, - video_quality_mode: Option, + pub name: Option, + pub channel_type: Option, + pub topic: Option, + pub icon: Option, + pub bitrate: Option, + pub user_limit: Option, + pub rate_limit_per_user: Option, + pub position: Option, + pub permission_overwrites: Option>, + pub parent_id: Option, + pub nsfw: Option, + pub rtc_region: Option, + pub default_auto_archive_duration: Option, + pub default_reaction_emoji: Option, + pub flags: Option, + pub default_thread_rate_limit_per_user: Option, + pub video_quality_mode: Option, } From d44193618e0f58980da939bf05a8d7030e8782b5 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 18:50:09 +0200 Subject: [PATCH 25/42] ADd test for modify_channel() --- tests/channel.rs | 38 +++++++++++++++++++++++++++++++++++++- 1 file changed, 37 insertions(+), 1 deletion(-) diff --git a/tests/channel.rs b/tests/channel.rs index 03e570f..56f1ce5 100644 --- a/tests/channel.rs +++ b/tests/channel.rs @@ -1,5 +1,5 @@ mod common; -use chorus::types::Channel; +use chorus::types::{self, Channel}; #[tokio::test] async fn get_channel() { @@ -38,3 +38,39 @@ async fn delete_channel() { assert!(result.is_none()); common::teardown(bundle).await } + +#[tokio::test] +async fn modify_channel() { + let mut bundle = common::setup().await; + let modify_data: types::ChannelModifySchema = types::ChannelModifySchema { + name: Some("beepboop".to_string()), + channel_type: None, + topic: None, + icon: None, + bitrate: None, + user_limit: None, + rate_limit_per_user: None, + position: None, + permission_overwrites: None, + parent_id: None, + nsfw: None, + rtc_region: None, + default_auto_archive_duration: None, + default_reaction_emoji: None, + flags: None, + default_thread_rate_limit_per_user: None, + video_quality_mode: None, + }; + let result = Channel::modify( + modify_data, + &bundle.user.token, + bundle.instance.urls.get_api(), + &bundle.channel.id.to_string(), + &mut bundle.user.limits, + &mut bundle.instance.limits, + ) + .await + .unwrap(); + assert_eq!(result.name, Some("beepboop".to_string())); + common::teardown(bundle).await +} From f18d3d7707d5b74ccbe8d1e60b855982379bccda Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 18:50:19 +0200 Subject: [PATCH 26/42] Add clone, default derives --- src/types/schema/channel.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/types/schema/channel.rs b/src/types/schema/channel.rs index 67d9823..fb626bb 100644 --- a/src/types/schema/channel.rs +++ b/src/types/schema/channel.rs @@ -26,7 +26,7 @@ pub struct ChannelCreateSchema { pub video_quality_mode: Option, } -#[derive(Debug, Deserialize, Serialize)] +#[derive(Debug, Deserialize, Serialize, Clone, Default)] #[serde(rename_all = "snake_case")] pub struct ChannelModifySchema { pub name: Option, From 78da2d00a4f985ec5bac4f9c495fff05602628b3 Mon Sep 17 00:00:00 2001 From: Flori <39242991+bitfl0wer@users.noreply.github.com> Date: Mon, 29 May 2023 19:05:26 +0200 Subject: [PATCH 27/42] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 23acd09..0cb8f0f 100644 --- a/README.md +++ b/README.md @@ -42,7 +42,7 @@ - [ ] [Events (Message, User, Channel, etc.)](https://github.com/polyphony-chat/chorus/issues/51) - [x] Channel creation - [x] Channel deletion -- [ ] [Channel management (name, description, icon, etc.)](https://github.com/polyphony-chat/chorus/issues/48) +- [x] [Channel management (name, description, icon, etc.)](https://github.com/polyphony-chat/chorus/issues/48) - [ ] Deleting messages - [ ] Message threads - [ ] Reactions From 315ebe6914705c57aad6f72a93625620a453d7ce Mon Sep 17 00:00:00 2001 From: Flori <39242991+bitfl0wer@users.noreply.github.com> Date: Mon, 29 May 2023 19:20:41 +0200 Subject: [PATCH 28/42] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 0cb8f0f..bc696a1 100644 --- a/README.md +++ b/README.md @@ -39,7 +39,7 @@ ### Messaging - [x] [Sending messages](https://github.com/polyphony-chat/chorus/issues/23) -- [ ] [Events (Message, User, Channel, etc.)](https://github.com/polyphony-chat/chorus/issues/51) +- [x] [Events (Message, User, Channel, etc.)](https://github.com/polyphony-chat/chorus/issues/51) - [x] Channel creation - [x] Channel deletion - [x] [Channel management (name, description, icon, etc.)](https://github.com/polyphony-chat/chorus/issues/48) From 001dc9f80ccf77857172ac31c84f1ee7d6d7a8f9 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 23:01:17 +0200 Subject: [PATCH 29/42] Refactor get() to take less boilerplate args --- src/api/channels/channels.rs | 21 ++++++++++++--------- tests/channel.rs | 14 ++++---------- 2 files changed, 16 insertions(+), 19 deletions(-) diff --git a/src/api/channels/channels.rs b/src/api/channels/channels.rs index bfe9959..21026b6 100644 --- a/src/api/channels/channels.rs +++ b/src/api/channels/channels.rs @@ -4,28 +4,31 @@ use serde_json::{from_str, to_string}; use crate::{ api::limits::Limits, errors::InstanceServerError, + instance::UserMeta, limit::LimitedRequester, types::{Channel, ChannelModifySchema}, }; impl Channel { pub async fn get( - token: &str, - url_api: &str, + user: &mut UserMeta, channel_id: &str, - limits_user: &mut Limits, - limits_instance: &mut Limits, ) -> Result { + let mut belongs_to = user.belongs_to.borrow_mut(); let request = Client::new() - .get(format!("{}/channels/{}/", url_api, channel_id)) - .bearer_auth(token); + .get(format!( + "{}/channels/{}/", + belongs_to.urls.get_api(), + channel_id + )) + .bearer_auth(user.token()); let mut requester = LimitedRequester::new().await; let result = match requester .send_request( request, crate::api::limits::LimitType::Guild, - limits_instance, - limits_user, + &mut belongs_to.limits, + &mut user.limits, ) .await { @@ -36,7 +39,7 @@ impl Channel { match from_str::(&result_text) { Ok(object) => Ok(object), Err(e) => Err(InstanceServerError::RequestErrorError { - url: format!("{}/channels/{}/", url_api, channel_id), + url: format!("{}/channels/{}/", belongs_to.urls.get_api(), channel_id), error: e.to_string(), }), } diff --git a/tests/channel.rs b/tests/channel.rs index 56f1ce5..58776b0 100644 --- a/tests/channel.rs +++ b/tests/channel.rs @@ -5,19 +5,13 @@ use chorus::types::{self, Channel}; async fn get_channel() { let mut bundle = common::setup().await; let bundle_channel = bundle.channel.clone(); - let bundle_user = &mut bundle.user; + let mut bundle_user = &mut bundle.user; assert_eq!( bundle_channel, - Channel::get( - bundle_user.token.as_str(), - bundle.instance.urls.get_api(), - &bundle_channel.id.to_string(), - &mut bundle_user.limits, - &mut bundle.instance.limits - ) - .await - .unwrap() + Channel::get(&mut bundle_user, &bundle_channel.id.to_string(),) + .await + .unwrap() ); common::teardown(bundle).await } From 808224d4fb2915c83cd1d63362e1eb9b2616c998 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 23:08:52 +0200 Subject: [PATCH 30/42] Refactor delete() to take less boilerplate args --- src/api/channels/channels.rs | 21 ++++++++++----------- tests/channel.rs | 11 +---------- 2 files changed, 11 insertions(+), 21 deletions(-) diff --git a/src/api/channels/channels.rs b/src/api/channels/channels.rs index 21026b6..4193933 100644 --- a/src/api/channels/channels.rs +++ b/src/api/channels/channels.rs @@ -58,23 +58,22 @@ impl Channel { /// # Returns /// /// An `Option` that contains an `InstanceServerError` if an error occurred during the request, or `None` if the request was successful. - pub async fn delete( - self, - token: &str, - url_api: &str, - limits_user: &mut Limits, - limits_instance: &mut Limits, - ) -> Option { + pub async fn delete(self, user: &mut UserMeta) -> Option { + let mut belongs_to = user.belongs_to.borrow_mut(); let request = Client::new() - .delete(format!("{}/channels/{}/", url_api, self.id.to_string())) - .bearer_auth(token); + .delete(format!( + "{}/channels/{}/", + belongs_to.urls.get_api(), + self.id.to_string() + )) + .bearer_auth(user.token()); match LimitedRequester::new() .await .send_request( request, crate::api::limits::LimitType::Channel, - limits_instance, - limits_user, + &mut belongs_to.limits, + &mut user.limits, ) .await { diff --git a/tests/channel.rs b/tests/channel.rs index 58776b0..101fe8a 100644 --- a/tests/channel.rs +++ b/tests/channel.rs @@ -19,16 +19,7 @@ async fn get_channel() { #[tokio::test] async fn delete_channel() { let mut bundle = common::setup().await; - let result = bundle - .channel - .clone() - .delete( - &bundle.user.token, - bundle.instance.urls.get_api(), - &mut bundle.user.limits, - &mut bundle.instance.limits, - ) - .await; + let result = bundle.channel.clone().delete(&mut bundle.user).await; assert!(result.is_none()); common::teardown(bundle).await } From a12573fe1c023bf7bb9808488e5158d6733bb4f3 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 23:11:12 +0200 Subject: [PATCH 31/42] Refactor modify() to take less boilerplate args --- src/api/channels/channels.rs | 18 ++++++++++-------- tests/channel.rs | 5 +---- 2 files changed, 11 insertions(+), 12 deletions(-) diff --git a/src/api/channels/channels.rs b/src/api/channels/channels.rs index 4193933..690ec28 100644 --- a/src/api/channels/channels.rs +++ b/src/api/channels/channels.rs @@ -98,23 +98,25 @@ impl Channel { /// A `Result` that contains a `Channel` object if the request was successful, or an `InstanceServerError` if an error occurred during the request. pub async fn modify( modify_data: ChannelModifySchema, - token: &str, - url_api: &str, channel_id: &str, - limits_user: &mut Limits, - limits_instance: &mut Limits, + user: &mut UserMeta, ) -> Result { + let mut belongs_to = user.belongs_to.borrow_mut(); let request = Client::new() - .patch(format!("{}/channels/{}/", url_api, channel_id)) - .bearer_auth(token) + .patch(format!( + "{}/channels/{}/", + belongs_to.urls.get_api(), + channel_id + )) + .bearer_auth(user.token()) .body(to_string(&modify_data).unwrap()); let channel = match LimitedRequester::new() .await .send_request( request, crate::api::limits::LimitType::Channel, - limits_instance, - limits_user, + &mut belongs_to.limits, + &mut user.limits, ) .await { diff --git a/tests/channel.rs b/tests/channel.rs index 101fe8a..85b019b 100644 --- a/tests/channel.rs +++ b/tests/channel.rs @@ -48,11 +48,8 @@ async fn modify_channel() { }; let result = Channel::modify( modify_data, - &bundle.user.token, - bundle.instance.urls.get_api(), &bundle.channel.id.to_string(), - &mut bundle.user.limits, - &mut bundle.instance.limits, + &mut bundle.user, ) .await .unwrap(); From 1e79a1a7ab9adaace6bd2b4bc8b84e58993f5d04 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 23:15:05 +0200 Subject: [PATCH 32/42] Refactor message::send() --- src/api/channels/messages.rs | 45 ++++++++++++++++++------------------ 1 file changed, 22 insertions(+), 23 deletions(-) diff --git a/src/api/channels/messages.rs b/src/api/channels/messages.rs index 7b43eef..336d563 100644 --- a/src/api/channels/messages.rs +++ b/src/api/channels/messages.rs @@ -4,7 +4,6 @@ pub mod messages { use reqwest::{multipart, Client}; use serde_json::to_string; - use crate::api::limits::Limits; use crate::instance::UserMeta; use crate::limit::LimitedRequester; use crate::types::{Message, MessageSendSchema, PartialDiscordFileAttachment}; @@ -22,27 +21,26 @@ pub mod messages { * [`InstanceServerError`] - If the message cannot be sent. */ pub async fn send<'a>( - url_api: String, + user: &mut UserMeta, channel_id: String, message: &mut MessageSendSchema, files: Option>, - token: String, - limits_user: &mut Limits, - limits_instance: &mut Limits, ) -> Result { + let mut belongs_to = user.belongs_to.borrow_mut(); + let url_api = belongs_to.urls.get_api(); let mut requester = LimitedRequester::new().await; if files.is_none() { let message_request = Client::new() .post(format!("{}/channels/{}/messages/", url_api, channel_id)) - .bearer_auth(token) + .bearer_auth(user.token()) .body(to_string(message).unwrap()); requester .send_request( message_request, crate::api::limits::LimitType::Channel, - limits_instance, - limits_user, + &mut belongs_to.limits, + &mut user.limits, ) .await } else { @@ -75,15 +73,15 @@ pub mod messages { let message_request = Client::new() .post(format!("{}/channels/{}/messages/", url_api, channel_id)) - .bearer_auth(token) + .bearer_auth(user.token()) .multipart(form); requester .send_request( message_request, crate::api::limits::LimitType::Channel, - limits_instance, - limits_user, + &mut belongs_to.limits, + &mut user.limits, ) .await } @@ -91,24 +89,25 @@ pub mod messages { } impl UserMeta { + /// Shorthand call for Message::send() + /** + Sends a message to the Spacebar server. + # Arguments + * `url_api` - The URL of the Spacebar server's API. + * `message` - The [`Message`] that will be sent to the Spacebar server. + * `limits_user` - The [`Limits`] of the user. + * `limits_instance` - The [`Limits`] of the instance. + * `requester` - The [`LimitedRequester`] that will be used to make requests to the Spacebar server. + # Errors + * [`InstanceServerError`] - If the message cannot be sent. + */ pub async fn send_message( &mut self, message: &mut MessageSendSchema, channel_id: String, files: Option>, ) -> Result { - let token = self.token().clone(); - let mut belongs_to = self.belongs_to.borrow_mut(); - Message::send( - belongs_to.urls.get_api().to_string(), - channel_id, - message, - files, - token, - &mut self.limits, - &mut belongs_to.limits, - ) - .await + Message::send(self, channel_id, message, files).await } } } From eaf45274a612796a35b319f29073a31a6c15d0b1 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 23:16:43 +0200 Subject: [PATCH 33/42] Refactor Guild create --- src/api/guilds/guilds.rs | 6 +++--- tests/guild.rs | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/api/guilds/guilds.rs b/src/api/guilds/guilds.rs index 45482b3..e153f09 100644 --- a/src/api/guilds/guilds.rs +++ b/src/api/guilds/guilds.rs @@ -27,10 +27,10 @@ impl Guild { /// pub async fn create( user: &mut UserMeta, - url_api: &str, guild_create_schema: GuildCreateSchema, ) -> Result { - let url = format!("{}/guilds/", url_api); + let belongs_to = user.belongs_to.borrow_mut(); + let url = format!("{}/guilds/", belongs_to.urls.get_api()); let mut limits_user = user.limits.get_as_mut(); let mut limits_instance = &mut user.belongs_to.borrow_mut().limits; let request = reqwest::Client::new() @@ -52,7 +52,7 @@ impl Guild { }; let id: GuildCreateResponse = from_str(&result.text().await.unwrap()).unwrap(); let guild = Guild::get( - url_api, + belongs_to.urls.get_api(), &id.id, &user.token, &mut limits_user, diff --git a/tests/guild.rs b/tests/guild.rs index 48794d8..56cb51d 100644 --- a/tests/guild.rs +++ b/tests/guild.rs @@ -15,7 +15,7 @@ async fn guild_creation_deletion() { rules_channel_id: None, }; - let guild = Guild::create(&mut bundle.user, bundle.urls.get_api(), guild_create_schema) + let guild = Guild::create(&mut bundle.user, guild_create_schema) .await .unwrap(); From e03c51658d2e7d60fa4ca7f8067a4c1051378dba Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 23:46:17 +0200 Subject: [PATCH 34/42] Remove unnecessary lifetime --- src/api/channels/messages.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/api/channels/messages.rs b/src/api/channels/messages.rs index 336d563..cd2b899 100644 --- a/src/api/channels/messages.rs +++ b/src/api/channels/messages.rs @@ -20,7 +20,7 @@ pub mod messages { # Errors * [`InstanceServerError`] - If the message cannot be sent. */ - pub async fn send<'a>( + pub async fn send( user: &mut UserMeta, channel_id: String, message: &mut MessageSendSchema, From 96ace34137a04fb94ce43e36e8e825418a516a18 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 23:46:43 +0200 Subject: [PATCH 35/42] Refactor create() and get() --- src/api/guilds/guilds.rs | 32 ++++++++++++++++++++++---------- tests/common/mod.rs | 4 +--- 2 files changed, 23 insertions(+), 13 deletions(-) diff --git a/src/api/guilds/guilds.rs b/src/api/guilds/guilds.rs index e153f09..02bf58d 100644 --- a/src/api/guilds/guilds.rs +++ b/src/api/guilds/guilds.rs @@ -29,10 +29,8 @@ impl Guild { user: &mut UserMeta, guild_create_schema: GuildCreateSchema, ) -> Result { - let belongs_to = user.belongs_to.borrow_mut(); + let mut belongs_to = user.belongs_to.borrow_mut(); let url = format!("{}/guilds/", belongs_to.urls.get_api()); - let mut limits_user = user.limits.get_as_mut(); - let mut limits_instance = &mut user.belongs_to.borrow_mut().limits; let request = reqwest::Client::new() .post(url.clone()) .bearer_auth(user.token.clone()) @@ -42,8 +40,8 @@ impl Guild { .send_request( request, crate::api::limits::LimitType::Guild, - limits_instance, - limits_user, + &mut belongs_to.limits, + &mut user.limits, ) .await { @@ -51,12 +49,12 @@ impl Guild { Err(e) => return Err(e), }; let id: GuildCreateResponse = from_str(&result.text().await.unwrap()).unwrap(); - let guild = Guild::get( - belongs_to.urls.get_api(), + let guild = Guild::_get( + belongs_to.clone().urls.get_api(), &id.id, &user.token, - &mut limits_user, - &mut limits_instance, + &mut user.limits, + &mut belongs_to.limits, ) .await .unwrap(); @@ -210,7 +208,21 @@ impl Guild { /// * `limits_user` - A mutable reference to a `Limits` struct containing the user's rate limits. /// * `limits_instance` - A mutable reference to a `Limits` struct containing the instance's rate limits. /// - pub async fn get( + pub async fn get(user: &mut UserMeta, guild_id: &str) -> Result { + let mut belongs_to = user.belongs_to.borrow_mut(); + Guild::_get( + &format!("{}", belongs_to.urls.get_api()), + guild_id, + &user.token, + &mut user.limits, + &mut belongs_to.limits, + ) + .await + } + + /// For internal use. Does the same as the public get method, but does not require a second, mutable + /// borrow of `UserMeta::belongs_to`, when used in conjunction with other methods, which borrow `UserMeta::belongs_to`. + async fn _get( url_api: &str, guild_id: &str, token: &str, diff --git a/tests/common/mod.rs b/tests/common/mod.rs index 61fb2fc..2bb0883 100644 --- a/tests/common/mod.rs +++ b/tests/common/mod.rs @@ -65,9 +65,7 @@ pub async fn setup() -> TestBundle { video_quality_mode: None, }; let mut user = instance.register_account(®).await.unwrap(); - let guild = Guild::create(&mut user, urls.get_api(), guild_create_schema) - .await - .unwrap(); + let guild = Guild::create(&mut user, guild_create_schema).await.unwrap(); let channel = Channel::create( &user.token, urls.get_api(), From d8d3bf5be6f56e46a30b60ea6d7554002d69dd2f Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 23:51:12 +0200 Subject: [PATCH 36/42] Refactor delete() --- src/api/guilds/guilds.rs | 15 +++++---------- tests/common/mod.rs | 7 +------ tests/guild.rs | 8 +------- 3 files changed, 7 insertions(+), 23 deletions(-) diff --git a/src/api/guilds/guilds.rs b/src/api/guilds/guilds.rs index 02bf58d..aef5eb4 100644 --- a/src/api/guilds/guilds.rs +++ b/src/api/guilds/guilds.rs @@ -85,14 +85,9 @@ impl Guild { /// None => println!("Guild deleted successfully"), /// } /// ``` - pub async fn delete( - user: &mut UserMeta, - url_api: &str, - guild_id: &str, - ) -> Option { - let url = format!("{}/guilds/{}/delete/", url_api, guild_id); - let limits_user = user.limits.get_as_mut(); - let limits_instance = &mut user.belongs_to.borrow_mut().limits; + pub async fn delete(user: &mut UserMeta, guild_id: &str) -> Option { + let mut belongs_to = user.belongs_to.borrow_mut(); + let url = format!("{}/guilds/{}/delete/", belongs_to.urls.get_api(), guild_id); let request = reqwest::Client::new() .post(url.clone()) .bearer_auth(user.token.clone()); @@ -101,8 +96,8 @@ impl Guild { .send_request( request, crate::api::limits::LimitType::Guild, - limits_instance, - limits_user, + &mut belongs_to.limits, + &mut user.limits, ) .await; if result.is_err() { diff --git a/tests/common/mod.rs b/tests/common/mod.rs index 2bb0883..f8991e3 100644 --- a/tests/common/mod.rs +++ b/tests/common/mod.rs @@ -88,11 +88,6 @@ pub async fn setup() -> TestBundle { // Teardown method to clean up after a test. pub async fn teardown(mut bundle: TestBundle) { - Guild::delete( - &mut bundle.user, - bundle.instance.urls.get_api(), - &bundle.guild.id.to_string(), - ) - .await; + Guild::delete(&mut bundle.user, &bundle.guild.id.to_string()).await; bundle.user.delete().await; } diff --git a/tests/guild.rs b/tests/guild.rs index 56cb51d..8bd0838 100644 --- a/tests/guild.rs +++ b/tests/guild.rs @@ -19,13 +19,7 @@ async fn guild_creation_deletion() { .await .unwrap(); - match Guild::delete( - &mut bundle.user, - bundle.urls.get_api(), - &guild.id.to_string(), - ) - .await - { + match Guild::delete(&mut bundle.user, &guild.id.to_string()).await { None => assert!(true), Some(_) => assert!(false), } From 3cebafecf60c29a4354f5e5cb8dd337a3b7606b8 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 23:57:23 +0200 Subject: [PATCH 37/42] Refactor create --- src/api/guilds/guilds.rs | 33 ++++++++++++++++++++++++--------- tests/common/mod.rs | 13 +++---------- 2 files changed, 27 insertions(+), 19 deletions(-) diff --git a/src/api/guilds/guilds.rs b/src/api/guilds/guilds.rs index aef5eb4..118a25e 100644 --- a/src/api/guilds/guilds.rs +++ b/src/api/guilds/guilds.rs @@ -122,19 +122,17 @@ impl Guild { /// A `Result` containing a `reqwest::Response` if the request was successful, or an `InstanceServerError` if there was an error. pub async fn create_channel( &self, - url_api: &str, - token: &str, + user: &mut UserMeta, schema: ChannelCreateSchema, - limits_user: &mut Limits, - limits_instance: &mut Limits, ) -> Result { - Channel::create( - token, - url_api, + let mut belongs_to = user.belongs_to.borrow_mut(); + Channel::_create( + &user.token, + &format!("{}", belongs_to.urls.get_api()), &self.id.to_string(), schema, - limits_user, - limits_instance, + &mut user.limits, + &mut belongs_to.limits, ) .await } @@ -261,6 +259,23 @@ impl Channel { /// /// A `Result` containing a `reqwest::Response` if the request was successful, or an `InstanceServerError` if there was an error. pub async fn create( + user: &mut UserMeta, + guild_id: &str, + schema: ChannelCreateSchema, + ) -> Result { + let mut belongs_to = user.belongs_to.borrow_mut(); + Channel::_create( + &user.token, + &format!("{}", belongs_to.urls.get_api()), + guild_id, + schema, + &mut user.limits, + &mut belongs_to.limits, + ) + .await + } + + async fn _create( token: &str, url_api: &str, guild_id: &str, diff --git a/tests/common/mod.rs b/tests/common/mod.rs index f8991e3..4b20399 100644 --- a/tests/common/mod.rs +++ b/tests/common/mod.rs @@ -66,16 +66,9 @@ pub async fn setup() -> TestBundle { }; let mut user = instance.register_account(®).await.unwrap(); let guild = Guild::create(&mut user, guild_create_schema).await.unwrap(); - let channel = Channel::create( - &user.token, - urls.get_api(), - &guild.id.to_string(), - channel_create_schema, - &mut user.limits, - &mut instance.limits, - ) - .await - .unwrap(); + let channel = Channel::create(&mut user, &guild.id.to_string(), channel_create_schema) + .await + .unwrap(); TestBundle { urls, From b1dbc5304976b427b258fd6ad6da06209cce1234 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Mon, 29 May 2023 23:59:13 +0200 Subject: [PATCH 38/42] Refactor channels() --- src/api/guilds/guilds.rs | 17 ++++++----------- tests/guild.rs | 11 +---------- 2 files changed, 7 insertions(+), 21 deletions(-) diff --git a/src/api/guilds/guilds.rs b/src/api/guilds/guilds.rs index 118a25e..f267e55 100644 --- a/src/api/guilds/guilds.rs +++ b/src/api/guilds/guilds.rs @@ -146,27 +146,22 @@ impl Guild { /// * `limits_user` - A mutable reference to a `Limits` struct containing the user's rate limits. /// * `limits_instance` - A mutable reference to a `Limits` struct containing the instance's rate limits. /// - pub async fn channels( - &self, - url_api: &str, - token: &str, - limits_user: &mut Limits, - limits_instance: &mut Limits, - ) -> Result, InstanceServerError> { + pub async fn channels(&self, user: &mut UserMeta) -> Result, InstanceServerError> { + let mut belongs_to = user.belongs_to.borrow_mut(); let request = Client::new() .get(format!( "{}/guilds/{}/channels/", - url_api, + belongs_to.urls.get_api(), self.id.to_string() )) - .bearer_auth(token); + .bearer_auth(user.token()); let result = match LimitedRequester::new() .await .send_request( request, crate::api::limits::LimitType::Guild, - limits_instance, - limits_user, + &mut belongs_to.limits, + &mut user.limits, ) .await { diff --git a/tests/guild.rs b/tests/guild.rs index 8bd0838..8143532 100644 --- a/tests/guild.rs +++ b/tests/guild.rs @@ -31,16 +31,7 @@ async fn get_channels() { let mut bundle = common::setup().await; println!( "{:?}", - bundle - .guild - .channels( - bundle.instance.urls.get_api(), - &bundle.user.token, - &mut bundle.user.limits, - &mut bundle.instance.limits, - ) - .await - .unwrap() + bundle.guild.channels(&mut bundle.user).await.unwrap() ); common::teardown(bundle).await; } From 5a9a156846eaf3c5a3258425525f576003ee9a62 Mon Sep 17 00:00:00 2001 From: Zertex Date: Tue, 30 May 2023 10:57:34 -0400 Subject: [PATCH 39/42] make the tests pass --- src/types/entities/guild.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/types/entities/guild.rs b/src/types/entities/guild.rs index e455c09..1b4d641 100644 --- a/src/types/entities/guild.rs +++ b/src/types/entities/guild.rs @@ -35,6 +35,7 @@ pub struct Guild { #[cfg_attr(feature = "sqlx", sqlx(skip))] pub roles: Option>, #[cfg_attr(feature = "sqlx", sqlx(skip))] + #[serde(default)] pub emojis: Vec, //#[cfg_attr(feature = "sqlx", sqlx(try_from = "String"))] pub features: GuildFeaturesList, From dc40c69ebe9e169b071c7ff61e8446ec8518baa8 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Tue, 30 May 2023 23:04:22 +0200 Subject: [PATCH 40/42] Refactored users() as much as possible --- src/api/users/users.rs | 34 +++++++++++++++++++++++----------- 1 file changed, 23 insertions(+), 11 deletions(-) diff --git a/src/api/users/users.rs b/src/api/users/users.rs index dacff1f..2cdaa74 100644 --- a/src/api/users/users.rs +++ b/src/api/users/users.rs @@ -21,12 +21,10 @@ impl UserMeta { * [`InstanceServerError`] - If the request fails. */ pub async fn get( - token: &String, - url_api: &String, + user: &mut UserMeta, id: Option<&String>, - instance_limits: &mut Limits, ) -> Result { - User::get(token, url_api, id, instance_limits).await + User::get(user, id).await } pub async fn get_settings( @@ -116,10 +114,24 @@ impl UserMeta { impl User { pub async fn get( - token: &String, - url_api: &String, + user: &mut UserMeta, + id: Option<&String>, + ) -> Result { + let mut belongs_to = user.belongs_to.borrow_mut(); + User::_get( + &user.token(), + &format!("{}", belongs_to.urls.get_api()), + &mut belongs_to.limits, + id, + ) + .await + } + + async fn _get( + token: &str, + url_api: &str, + limits_instance: &mut Limits, id: Option<&String>, - instance_limits: &mut Limits, ) -> Result { let url: String; if id.is_none() { @@ -129,12 +141,12 @@ impl User { } let request = reqwest::Client::new().get(url).bearer_auth(token); let mut requester = crate::limit::LimitedRequester::new().await; - let mut cloned_limits = instance_limits.clone(); + let mut cloned_limits = limits_instance.clone(); match requester .send_request( request, crate::api::limits::LimitType::Ip, - instance_limits, + limits_instance, &mut cloned_limits, ) .await @@ -188,11 +200,11 @@ impl Instance { token: String, id: Option<&String>, ) -> Result { - UserMeta::get( + User::_get( &token, &self.urls.get_api().to_string(), - id, &mut self.limits, + id, ) .await } From cda1f564ae1da9a0a172e4df3941c1f1a6feebfe Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Thu, 1 Jun 2023 18:20:55 +0200 Subject: [PATCH 41/42] We had two types directories this whole time??? --- types/config/mod.rs | 187 -------------- types/config/types/api_configuration.rs | 24 -- types/config/types/cdn_configuration.rs | 25 -- types/config/types/defaults_configuration.rs | 10 - types/config/types/email_configuration.rs | 27 -- types/config/types/endpoint_configuration.rs | 9 - .../types/external_tokens_configuration.rs | 7 - types/config/types/general_configuration.rs | 35 --- types/config/types/gif_configuration.rs | 26 -- types/config/types/guild_configuration.rs | 126 --------- types/config/types/kafka_configuration.rs | 10 - types/config/types/limit_configuration.rs | 17 -- types/config/types/login_configuration.rs | 8 - types/config/types/metrics_configuration.rs | 13 - types/config/types/mod.rs | 21 -- .../types/password_reset_configuration.rs | 7 - types/config/types/rabbit_mq_configuration.rs | 7 - types/config/types/region_configuration.rs | 29 --- types/config/types/register_configuration.rs | 41 --- types/config/types/security_configuration.rs | 42 --- types/config/types/sentry_configuration.rs | 28 -- types/config/types/subconfigs/client/mod.rs | 17 -- .../config/types/subconfigs/defaults/guild.rs | 23 -- types/config/types/subconfigs/defaults/mod.rs | 2 - .../config/types/subconfigs/defaults/user.rs | 19 -- .../config/types/subconfigs/email/mailgun.rs | 8 - .../config/types/subconfigs/email/mailjet.rs | 8 - types/config/types/subconfigs/email/mod.rs | 4 - .../config/types/subconfigs/email/sendgrid.rs | 7 - types/config/types/subconfigs/email/smtp.rs | 10 - .../config/types/subconfigs/guild/autojoin.rs | 22 -- .../types/subconfigs/guild/discovery.rs | 21 -- types/config/types/subconfigs/guild/mod.rs | 2 - types/config/types/subconfigs/kafka/mod.rs | 7 - .../config/types/subconfigs/limits/channel.rs | 19 -- .../config/types/subconfigs/limits/global.rs | 41 --- types/config/types/subconfigs/limits/guild.rs | 23 -- .../config/types/subconfigs/limits/message.rs | 26 -- types/config/types/subconfigs/limits/mod.rs | 7 - .../subconfigs/limits/ratelimits/auth.rs | 28 -- .../types/subconfigs/limits/ratelimits/mod.rs | 14 - .../subconfigs/limits/ratelimits/route.rs | 37 --- types/config/types/subconfigs/limits/rates.rs | 41 --- types/config/types/subconfigs/limits/user.rs | 19 -- types/config/types/subconfigs/mod.rs | 9 - types/config/types/subconfigs/region/mod.rs | 21 -- .../subconfigs/register/date_of_birth.rs | 16 -- .../config/types/subconfigs/register/email.rs | 21 -- types/config/types/subconfigs/register/mod.rs | 7 - .../types/subconfigs/register/password.rs | 23 -- .../types/subconfigs/security/captcha.rs | 27 -- types/config/types/subconfigs/security/mod.rs | 5 - .../types/subconfigs/security/twofactor.rs | 15 -- types/config/types/template_configuration.rs | 21 -- types/entities/application.rs | 140 ---------- types/entities/attachment.rs | 113 --------- types/entities/channel.rs | 116 --------- types/entities/config.rs | 34 --- types/entities/emoji.rs | 15 -- types/entities/guild.rs | 117 --------- types/entities/guild_member.rs | 19 -- types/entities/integration.rs | 36 --- types/entities/message.rs | 185 -------------- types/entities/mod.rs | 37 --- types/entities/role.rs | 28 -- types/entities/security_key.rs | 26 -- types/entities/sticker.rs | 27 -- types/entities/team.rs | 20 -- types/entities/template.rs | 24 -- types/entities/user.rs | 112 -------- types/entities/user_settings.rs | 133 ---------- types/entities/voice_state.rs | 30 --- types/entities/webhook.rs | 32 --- types/errors.rs | 54 ---- types/events/channel.rs | 41 --- types/events/guild.rs | 41 --- types/events/heartbeat.rs | 17 -- types/events/hello.rs | 17 -- types/events/identify.rs | 22 -- types/events/message.rs | 101 -------- types/events/mod.rs | 41 --- types/events/presence.rs | 24 -- types/events/ready.rs | 15 -- types/events/request_members.rs | 15 -- types/events/resume.rs | 11 - types/events/thread.rs | 82 ------ types/events/user.rs | 12 - types/events/voice_status.rs | 13 - types/interfaces/activity.rs | 57 ----- types/interfaces/connected_account.rs | 0 types/interfaces/guild_welcome_screen.rs | 17 -- types/interfaces/interaction.rs | 39 --- types/interfaces/mod.rs | 11 - types/interfaces/status.rs | 9 - types/lib.rs | 7 - types/schema/apierror.rs | 72 ------ types/schema/auth.rs | 240 ------------------ types/schema/channel.rs | 27 -- types/schema/guild.rs | 14 - types/schema/message.rs | 47 ---- types/schema/mod.rs | 103 -------- types/schema/user.rs | 16 -- types/utils/jwt.rs | 44 ---- types/utils/mod.rs | 8 - types/utils/regexes.rs | 12 - types/utils/rights.rs | 127 --------- types/utils/snowflake.rs | 160 ------------ 107 files changed, 4029 deletions(-) delete mode 100644 types/config/mod.rs delete mode 100644 types/config/types/api_configuration.rs delete mode 100644 types/config/types/cdn_configuration.rs delete mode 100644 types/config/types/defaults_configuration.rs delete mode 100644 types/config/types/email_configuration.rs delete mode 100644 types/config/types/endpoint_configuration.rs delete mode 100644 types/config/types/external_tokens_configuration.rs delete mode 100644 types/config/types/general_configuration.rs delete mode 100644 types/config/types/gif_configuration.rs delete mode 100644 types/config/types/guild_configuration.rs delete mode 100644 types/config/types/kafka_configuration.rs delete mode 100644 types/config/types/limit_configuration.rs delete mode 100644 types/config/types/login_configuration.rs delete mode 100644 types/config/types/metrics_configuration.rs delete mode 100644 types/config/types/mod.rs delete mode 100644 types/config/types/password_reset_configuration.rs delete mode 100644 types/config/types/rabbit_mq_configuration.rs delete mode 100644 types/config/types/region_configuration.rs delete mode 100644 types/config/types/register_configuration.rs delete mode 100644 types/config/types/security_configuration.rs delete mode 100644 types/config/types/sentry_configuration.rs delete mode 100644 types/config/types/subconfigs/client/mod.rs delete mode 100644 types/config/types/subconfigs/defaults/guild.rs delete mode 100644 types/config/types/subconfigs/defaults/mod.rs delete mode 100644 types/config/types/subconfigs/defaults/user.rs delete mode 100644 types/config/types/subconfigs/email/mailgun.rs delete mode 100644 types/config/types/subconfigs/email/mailjet.rs delete mode 100644 types/config/types/subconfigs/email/mod.rs delete mode 100644 types/config/types/subconfigs/email/sendgrid.rs delete mode 100644 types/config/types/subconfigs/email/smtp.rs delete mode 100644 types/config/types/subconfigs/guild/autojoin.rs delete mode 100644 types/config/types/subconfigs/guild/discovery.rs delete mode 100644 types/config/types/subconfigs/guild/mod.rs delete mode 100644 types/config/types/subconfigs/kafka/mod.rs delete mode 100644 types/config/types/subconfigs/limits/channel.rs delete mode 100644 types/config/types/subconfigs/limits/global.rs delete mode 100644 types/config/types/subconfigs/limits/guild.rs delete mode 100644 types/config/types/subconfigs/limits/message.rs delete mode 100644 types/config/types/subconfigs/limits/mod.rs delete mode 100644 types/config/types/subconfigs/limits/ratelimits/auth.rs delete mode 100644 types/config/types/subconfigs/limits/ratelimits/mod.rs delete mode 100644 types/config/types/subconfigs/limits/ratelimits/route.rs delete mode 100644 types/config/types/subconfigs/limits/rates.rs delete mode 100644 types/config/types/subconfigs/limits/user.rs delete mode 100644 types/config/types/subconfigs/mod.rs delete mode 100644 types/config/types/subconfigs/region/mod.rs delete mode 100644 types/config/types/subconfigs/register/date_of_birth.rs delete mode 100644 types/config/types/subconfigs/register/email.rs delete mode 100644 types/config/types/subconfigs/register/mod.rs delete mode 100644 types/config/types/subconfigs/register/password.rs delete mode 100644 types/config/types/subconfigs/security/captcha.rs delete mode 100644 types/config/types/subconfigs/security/mod.rs delete mode 100644 types/config/types/subconfigs/security/twofactor.rs delete mode 100644 types/config/types/template_configuration.rs delete mode 100644 types/entities/application.rs delete mode 100644 types/entities/attachment.rs delete mode 100644 types/entities/channel.rs delete mode 100644 types/entities/config.rs delete mode 100644 types/entities/emoji.rs delete mode 100644 types/entities/guild.rs delete mode 100644 types/entities/guild_member.rs delete mode 100644 types/entities/integration.rs delete mode 100644 types/entities/message.rs delete mode 100644 types/entities/mod.rs delete mode 100644 types/entities/role.rs delete mode 100644 types/entities/security_key.rs delete mode 100644 types/entities/sticker.rs delete mode 100644 types/entities/team.rs delete mode 100644 types/entities/template.rs delete mode 100644 types/entities/user.rs delete mode 100644 types/entities/user_settings.rs delete mode 100644 types/entities/voice_state.rs delete mode 100644 types/entities/webhook.rs delete mode 100644 types/errors.rs delete mode 100644 types/events/channel.rs delete mode 100644 types/events/guild.rs delete mode 100644 types/events/heartbeat.rs delete mode 100644 types/events/hello.rs delete mode 100644 types/events/identify.rs delete mode 100644 types/events/message.rs delete mode 100644 types/events/mod.rs delete mode 100644 types/events/presence.rs delete mode 100644 types/events/ready.rs delete mode 100644 types/events/request_members.rs delete mode 100644 types/events/resume.rs delete mode 100644 types/events/thread.rs delete mode 100644 types/events/user.rs delete mode 100644 types/events/voice_status.rs delete mode 100644 types/interfaces/activity.rs delete mode 100644 types/interfaces/connected_account.rs delete mode 100644 types/interfaces/guild_welcome_screen.rs delete mode 100644 types/interfaces/interaction.rs delete mode 100644 types/interfaces/mod.rs delete mode 100644 types/interfaces/status.rs delete mode 100644 types/lib.rs delete mode 100644 types/schema/apierror.rs delete mode 100644 types/schema/auth.rs delete mode 100644 types/schema/channel.rs delete mode 100644 types/schema/guild.rs delete mode 100644 types/schema/message.rs delete mode 100644 types/schema/mod.rs delete mode 100644 types/schema/user.rs delete mode 100644 types/utils/jwt.rs delete mode 100644 types/utils/mod.rs delete mode 100644 types/utils/regexes.rs delete mode 100644 types/utils/rights.rs delete mode 100644 types/utils/snowflake.rs diff --git a/types/config/mod.rs b/types/config/mod.rs deleted file mode 100644 index 97b830a..0000000 --- a/types/config/mod.rs +++ /dev/null @@ -1,187 +0,0 @@ -use serde::{Deserialize, Serialize}; -use serde_json::{Map, Value}; - -pub use crate::{ - config::types::{ - api_configuration::ApiConfiguration, cdn_configuration::CdnConfiguration, - defaults_configuration::DefaultsConfiguration, email_configuration::EmailConfiguration, - endpoint_configuration::EndpointConfiguration, - external_tokens_configuration::ExternalTokensConfiguration, - general_configuration::GeneralConfiguration, gif_configuration::GifConfiguration, - guild_configuration::GuildConfiguration, kafka_configuration::KafkaConfiguration, - limit_configuration::LimitsConfiguration, login_configuration::LoginConfiguration, - metrics_configuration::MetricsConfiguration, - password_reset_configuration::PasswordResetConfiguration, - rabbit_mq_configuration::RabbitMQConfiguration, region_configuration::RegionConfiguration, - register_configuration::RegisterConfiguration, - security_configuration::SecurityConfiguration, sentry_configuration::SentryConfiguration, - template_configuration::TemplateConfiguration, - }, - entities::ConfigEntity, -}; - -mod types; - -#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct ConfigValue { - pub gateway: EndpointConfiguration, - pub cdn: CdnConfiguration, - pub api: ApiConfiguration, - pub general: GeneralConfiguration, - pub limits: LimitsConfiguration, - pub security: SecurityConfiguration, - pub login: LoginConfiguration, - pub register: RegisterConfiguration, - pub regions: RegionConfiguration, - pub guild: GuildConfiguration, - pub gif: GifConfiguration, - pub rabbitmq: RabbitMQConfiguration, - pub kafka: KafkaConfiguration, - pub templates: TemplateConfiguration, - pub metrics: MetricsConfiguration, - pub sentry: SentryConfiguration, - pub defaults: DefaultsConfiguration, - pub external: ExternalTokensConfiguration, - pub email: EmailConfiguration, - pub password_reset: PasswordResetConfiguration, -} - -impl ConfigValue { - pub fn to_pairs(&self) -> Vec { - let v = serde_json::json!(self); - - generate_pairs(&v, "") - } - - pub fn from_pairs(pairs: Vec) -> Self { - pairs_to_config(pairs) - } -} - -fn generate_pairs(obj: &Value, key: &str) -> Vec { - let mut pairs = Vec::new(); - match obj { - Value::Object(map) => { - for (k, v) in map { - let new_key = if key.is_empty() { - k.to_string() - } else { - format!("{}_{}", key, k) - }; - pairs.extend(generate_pairs(v, &new_key)); - } - } - Value::Array(arr) => { - for (i, v) in arr.iter().enumerate() { - let new_key = format!("{}_{}", key, i); - pairs.extend(generate_pairs(v, &new_key)); - } - } - _ => pairs.push(ConfigEntity { - key: key.to_string(), - value: Some(obj.clone()), - }), - } - pairs -} - -fn pairs_to_config(pairs: Vec) -> ConfigValue { - let mut value = Value::Object(Map::new()); - - for p in pairs { - let keys: Vec<&str> = p.key.split('_').collect(); - let mut path = vec![]; - - for (i, &key) in keys.iter().enumerate() { - path.push(key); - - if i == keys.len() - 1 { - insert_into(&mut value, &path, p.value.clone().unwrap_or(Value::Null)); - } else if keys[i+1].parse::().is_ok() { - if !path_exists(&value, &path) { - insert_into(&mut value, &path, Value::Array(Vec::new())); - } - } else if !path_exists(&value, &path) { - insert_into(&mut value, &path, Value::Object(Map::new())); - } - } - } - - serde_json::from_value(value).unwrap() -} - -fn path_exists(value: &Value, path: &[&str]) -> bool { - let mut current = value; - - for &key in path { - match current { - Value::Object(map) => { - if let Some(v) = map.get(key) { - current = v; - } else { - return false; - } - }, - Value::Array(arr) => { - if let Ok(index) = key.parse::() { - if let Some(v) = arr.get(index) { - current = v; - } else { - return false; - } - } else { - return false; - } - }, - _ => return false, - } - } - - true -} - -fn insert_into(value: &mut Value, path: &[&str], new_value: Value) { - let last_key = path.last().unwrap(); - let parent_path = &path[0..path.len()-1]; - - let mut current = value; - - for &key in parent_path { - current = match current { - Value::Object(map) => map.get_mut(key).unwrap(), - Value::Array(arr) => arr.get_mut(key.parse::().unwrap()).unwrap(), - _ => unreachable!(), - }; - } - - match current { - Value::Object(map) => { - map.insert((*last_key).to_string(), new_value); - }, - Value::Array(arr) => { - let index = last_key.parse::().unwrap(); - if index >= arr.len() { - arr.resize(index + 1, Value::Null); - } - arr[index] = new_value; - }, - _ => unreachable!(), - }; -} - -#[cfg(test)] -mod test { - use crate::config::{generate_pairs, pairs_to_config, ConfigValue}; - - #[test] - fn test_pairs() { - let c = ConfigValue::default(); - let v = serde_json::json!(&c); - - let pairs = generate_pairs(&v, ""); - - let cfg = pairs_to_config(pairs); - assert_eq!(cfg, c) - } -} diff --git a/types/config/types/api_configuration.rs b/types/config/types/api_configuration.rs deleted file mode 100644 index 2d617fe..0000000 --- a/types/config/types/api_configuration.rs +++ /dev/null @@ -1,24 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] -#[serde(rename_all = "camelCase")] -pub struct ApiConfiguration { - pub default_version: String, - pub active_versions: Vec, - pub endpoint_public: Option, -} - -impl Default for ApiConfiguration { - fn default() -> Self { - Self { - default_version: String::from("9"), - active_versions: vec![ - String::from("6"), - String::from("7"), - String::from("8"), - String::from("9"), - ], - endpoint_public: None, - } - } -} diff --git a/types/config/types/cdn_configuration.rs b/types/config/types/cdn_configuration.rs deleted file mode 100644 index 5c76273..0000000 --- a/types/config/types/cdn_configuration.rs +++ /dev/null @@ -1,25 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct CdnConfiguration { - pub resize_height_max: u64, - pub resize_width_max: u64, - pub imagor_server_url: Option, - - pub endpoint_public: Option, - pub endpoint_private: Option, -} - -impl Default for CdnConfiguration { - fn default() -> Self { - Self { - resize_height_max: 1000, - resize_width_max: 1000, - imagor_server_url: None, - - endpoint_private: None, - endpoint_public: None, - } - } -} diff --git a/types/config/types/defaults_configuration.rs b/types/config/types/defaults_configuration.rs deleted file mode 100644 index b89b304..0000000 --- a/types/config/types/defaults_configuration.rs +++ /dev/null @@ -1,10 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::config::types::subconfigs::defaults::{guild::GuildDefaults, user::UserDefaults}; - -#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct DefaultsConfiguration { - pub guild: GuildDefaults, - pub user: UserDefaults, -} diff --git a/types/config/types/email_configuration.rs b/types/config/types/email_configuration.rs deleted file mode 100644 index 3025487..0000000 --- a/types/config/types/email_configuration.rs +++ /dev/null @@ -1,27 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::config::types::subconfigs::email::{ - mailgun::MailGunConfiguration, mailjet::MailJetConfiguration, sendgrid::SendGridConfiguration, - smtp::SMTPConfiguration, -}; - -#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)] -pub enum EmailProvider { - Smtp, - MailGun, - MailJet, - SendGrid, -} - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -#[derive(Default)] -pub struct EmailConfiguration { - pub provider: Option, - pub smtp: SMTPConfiguration, - pub mailgun: MailGunConfiguration, - pub mailjet: MailJetConfiguration, - pub sendgrid: SendGridConfiguration, -} - - diff --git a/types/config/types/endpoint_configuration.rs b/types/config/types/endpoint_configuration.rs deleted file mode 100644 index b484791..0000000 --- a/types/config/types/endpoint_configuration.rs +++ /dev/null @@ -1,9 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct EndpointConfiguration { - pub endpoint_client: Option, - pub endpoint_private: Option, - pub endpoint_public: Option, -} diff --git a/types/config/types/external_tokens_configuration.rs b/types/config/types/external_tokens_configuration.rs deleted file mode 100644 index f417b2f..0000000 --- a/types/config/types/external_tokens_configuration.rs +++ /dev/null @@ -1,7 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct ExternalTokensConfiguration { - pub twitter: Option, -} diff --git a/types/config/types/general_configuration.rs b/types/config/types/general_configuration.rs deleted file mode 100644 index f67fdf2..0000000 --- a/types/config/types/general_configuration.rs +++ /dev/null @@ -1,35 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::utils::Snowflake; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct GeneralConfiguration { - pub instance_name: String, - pub instance_description: Option, - pub front_page: Option, - pub tos_page: Option, - pub correspondence_email: Option, - pub correspondence_user_id: Option, - pub image: Option, - pub instance_id: Option, - pub auto_create_bot_users: Option, -} - -impl Default for GeneralConfiguration { - fn default() -> Self { - Self { - instance_name: String::from("Spacebar Instance"), - instance_description: Some(String::from( - "This is a Spacebar instance made in the pre-release days", - )), - front_page: None, - tos_page: None, - correspondence_email: None, - correspondence_user_id: None, - image: None, - instance_id: Some(Snowflake::generate()), - auto_create_bot_users: Some(false), - } - } -} diff --git a/types/config/types/gif_configuration.rs b/types/config/types/gif_configuration.rs deleted file mode 100644 index 8644fb4..0000000 --- a/types/config/types/gif_configuration.rs +++ /dev/null @@ -1,26 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "lowercase")] -pub enum GifProvider { - #[default] - Tenor, -} - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct GifConfiguration { - pub enabled: bool, - pub provider: GifProvider, - pub api_key: Option, -} - -impl Default for GifConfiguration { - fn default() -> Self { - Self { - enabled: true, - provider: GifProvider::Tenor, - api_key: Some(String::from("LIVDSRZULELA")), - } - } -} diff --git a/types/config/types/guild_configuration.rs b/types/config/types/guild_configuration.rs deleted file mode 100644 index 536396e..0000000 --- a/types/config/types/guild_configuration.rs +++ /dev/null @@ -1,126 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::config::types::subconfigs::guild::{ - autojoin::AutoJoinConfiguration, discovery::DiscoverConfiguration, -}; - -#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)] -#[serde(rename_all = "SCREAMING_SNAKE_CASE")] -pub enum GuildFeatures { - ActivitiesAlpha, - ActivitiesEmployee, - ActivitiesInternalDev, - AnimatedBanner, - AnimatedIcon, - ApplicationCommandPermissionsV2, - AutoModeration, - AutoModTriggerKeywordFilter, - AutoModTriggerMLSpamFilter, - AutoModTriggerSpamLinkFilter, - AutoModTriggerUserProfile, - Banner, - BFG, - BoostingTiersExperimentMediumGuild, - BoostingTiersExperimentSmallGuild, - BotDeveloperEarlyAccess, - BurstReactions, - CommunityCanary, - CommunityExpLargeGated, - CommunityExpLargeUngated, - CommunityExpMedium, - ChannelEmojisGenerated, - ChannelHighlights, - ChannelHighlightsDisabled, - ClydeEnabled, - ClydeExperimentEnabled, - ClydeDisabled, - Community, - CreatorAcceptedNewTerms, - CreatorMonetizable, - CreatorMonetizableDisabled, - CreatorMonetizablePendingNewOwnerOnboarding, - CreatorMonetizableProvisional, - CreatorMonetizableRestricted, - CreatorMonetizableWhiteglove, - CreatorMonetizableApplicationAllowlist, - CreateStorePage, - DeveloperSupportServer, - DiscoverableDisabled, - Discoverable, - EnabledDiscoverableBefore, - ExposedToActivitiesWTPExperiment, - GuestsEnabled, - GuildAutomodDefaultList, - GuildCommunicationDisabledGuilds, - GuildHomeDeprecationOverride, - GuildHomeOverride, - GuildHomeTest, - GuildMemberVerificationExperiment, - GuildOnboarding, - GuildOnboardingAdminOnly, - GuildOnboardingEverEnabled, - GuildOnboardingHasPrompts, - GuildRoleSubscription, - GuildRoleSubscriptionPurchaseFeedbackLoop, - GuildRoleSubscriptionTrials, - GuildServerGuide, - GuildWebPageVanityURL, - HadEarlyActivitiesAccess, - HasDirectoryEntry, - HideFromExperimentUI, - Hub, - IncreasedThreadLimit, - InternalEmployeeOnly, - InviteSplash, - InvitesDisabled, - LinkedToHub, - MarketplacesConnectionRoles, - MemberProfiles, - MemberVerificationGateEnabled, - MemberVerificationManualApproval, - MobileWebRoleSubscriptionPurchasePage, - MonetizationEnabled, - MoreEmoji, - MoreStickers, - News, - NewThreadPermissions, - Partnered, - PremiumTier3Override, - PreviewEnabled, - RaidAlertsDisabled, - RelayEnabled, - RestrictSpamRiskGuild, - RoleIcons, - RoleSubscriptionsAvailableForPurchase, - RoleSubscriptionsEnabled, - RoleSubscriptionsEnabledForPurchase, - Shard, - SharedCanvasFriendsAndFamilyTest, - Soundboard, - SummariesEnabled, - SummariesEnabledGA, - SummariesDisabledByUser, - SummariesEnabledByUser, - TextInStageEnabled, - TextInVoiceEnabled, - ThreadsEnabledTesting, - ThreadsEnabled, - ThreadDefaultAutoArchiveDuration, - ThreadsOnlyChannel, - TicketedEventsEnabled, - TicketingEnabled, - VanityUrls, - Verified, - VIPRegions, - VoiceChannelEffects, - WelcomeScreenEnabled, -} - -#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct GuildConfiguration { - pub discovery: DiscoverConfiguration, - pub auto_join: AutoJoinConfiguration, - #[serde(default)] - pub default_features: Vec, -} diff --git a/types/config/types/kafka_configuration.rs b/types/config/types/kafka_configuration.rs deleted file mode 100644 index 050ffc3..0000000 --- a/types/config/types/kafka_configuration.rs +++ /dev/null @@ -1,10 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::config::types::subconfigs::kafka::KafkaBroker; - -#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct KafkaConfiguration { - #[serde(default)] - pub brokers: Option>, -} diff --git a/types/config/types/limit_configuration.rs b/types/config/types/limit_configuration.rs deleted file mode 100644 index ad2ad17..0000000 --- a/types/config/types/limit_configuration.rs +++ /dev/null @@ -1,17 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::config::types::subconfigs::limits::{ - channel::ChannelLimits, global::GlobalRateLimits, guild::GuildLimits, message::MessageLimits, - rates::RateLimits, user::UserLimits, -}; - -#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct LimitsConfiguration { - pub user: UserLimits, - pub guild: GuildLimits, - pub message: MessageLimits, - pub channel: ChannelLimits, - pub rate: RateLimits, - pub absolute_rate: GlobalRateLimits, -} diff --git a/types/config/types/login_configuration.rs b/types/config/types/login_configuration.rs deleted file mode 100644 index a2b1039..0000000 --- a/types/config/types/login_configuration.rs +++ /dev/null @@ -1,8 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct LoginConfiguration { - pub require_captcha: bool, - pub require_verification: bool, -} diff --git a/types/config/types/metrics_configuration.rs b/types/config/types/metrics_configuration.rs deleted file mode 100644 index 336ac84..0000000 --- a/types/config/types/metrics_configuration.rs +++ /dev/null @@ -1,13 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct MetricsConfiguration { - pub timeout: u64, -} - -impl Default for MetricsConfiguration { - fn default() -> Self { - Self { timeout: 30000 } - } -} diff --git a/types/config/types/mod.rs b/types/config/types/mod.rs deleted file mode 100644 index dce4eb0..0000000 --- a/types/config/types/mod.rs +++ /dev/null @@ -1,21 +0,0 @@ -pub mod api_configuration; -pub mod cdn_configuration; -pub mod defaults_configuration; -pub mod email_configuration; -pub mod endpoint_configuration; -pub mod external_tokens_configuration; -pub mod general_configuration; -pub mod gif_configuration; -pub mod guild_configuration; -pub mod kafka_configuration; -pub mod limit_configuration; -pub mod login_configuration; -pub mod metrics_configuration; -pub mod password_reset_configuration; -pub mod rabbit_mq_configuration; -pub mod region_configuration; -pub mod register_configuration; -pub mod security_configuration; -pub mod sentry_configuration; -pub mod subconfigs; -pub mod template_configuration; diff --git a/types/config/types/password_reset_configuration.rs b/types/config/types/password_reset_configuration.rs deleted file mode 100644 index 4dddae9..0000000 --- a/types/config/types/password_reset_configuration.rs +++ /dev/null @@ -1,7 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct PasswordResetConfiguration { - pub require_captcha: bool, -} diff --git a/types/config/types/rabbit_mq_configuration.rs b/types/config/types/rabbit_mq_configuration.rs deleted file mode 100644 index 2437055..0000000 --- a/types/config/types/rabbit_mq_configuration.rs +++ /dev/null @@ -1,7 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RabbitMQConfiguration { - pub host: Option, -} diff --git a/types/config/types/region_configuration.rs b/types/config/types/region_configuration.rs deleted file mode 100644 index 065a8f7..0000000 --- a/types/config/types/region_configuration.rs +++ /dev/null @@ -1,29 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::config::types::subconfigs::region::Region; - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RegionConfiguration { - pub default: String, - pub use_default_as_optimal: bool, - pub available: Vec, -} - -impl Default for RegionConfiguration { - fn default() -> Self { - Self { - default: String::from("spacebar"), - use_default_as_optimal: true, - available: vec![Region { - id: String::from("spacebar"), - name: String::from("spacebar"), - endpoint: String::from("127.0.0.1:3004"), - location: None, - vip: false, - custom: false, - deprecated: false, - }], - } - } -} diff --git a/types/config/types/register_configuration.rs b/types/config/types/register_configuration.rs deleted file mode 100644 index 304299a..0000000 --- a/types/config/types/register_configuration.rs +++ /dev/null @@ -1,41 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::config::types::subconfigs::register::{ - DateOfBirthConfiguration, PasswordConfiguration, RegistrationEmailConfiguration, -}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RegisterConfiguration { - pub email: RegistrationEmailConfiguration, - pub date_of_birth: DateOfBirthConfiguration, - pub password: PasswordConfiguration, - pub disabled: bool, - pub require_captcha: bool, - pub require_invite: bool, - pub guests_require_invite: bool, - pub allow_new_registration: bool, - pub allow_multiple_accounts: bool, - pub block_proxies: bool, - pub incrementing_discriminators: bool, - pub default_rights: String, -} - -impl Default for RegisterConfiguration { - fn default() -> Self { - Self { - email: RegistrationEmailConfiguration::default(), - date_of_birth: DateOfBirthConfiguration::default(), - password: PasswordConfiguration::default(), - disabled: false, - require_captcha: true, - require_invite: false, - guests_require_invite: true, - allow_new_registration: true, - allow_multiple_accounts: true, - block_proxies: true, - incrementing_discriminators: false, - default_rights: String::from("875069521787904"), - } - } -} diff --git a/types/config/types/security_configuration.rs b/types/config/types/security_configuration.rs deleted file mode 100644 index 65008da..0000000 --- a/types/config/types/security_configuration.rs +++ /dev/null @@ -1,42 +0,0 @@ -use base64::Engine; -use serde::{Deserialize, Serialize}; - -use crate::config::types::subconfigs::security::{CaptchaConfiguration, TwoFactorConfiguration}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct SecurityConfiguration { - pub captcha: CaptchaConfiguration, - pub two_factor: TwoFactorConfiguration, - pub auto_update: bool, - pub request_signature: String, - pub jwt_secret: String, - pub forwarded_for: Option, - pub ipdata_api_key: Option, - pub mfa_backup_code_count: u8, - pub stats_world_readable: bool, - pub default_registration_token_expiration: u64, -} - -impl Default for SecurityConfiguration { - fn default() -> Self { - let mut req_sig: [u8; 32] = [0; 32]; - let _ = openssl::rand::rand_bytes(&mut req_sig); - let mut jwt_secret: [u8; 256] = [0; 256]; - let _ = openssl::rand::rand_bytes(&mut jwt_secret); - Self { - captcha: Default::default(), - two_factor: Default::default(), - auto_update: true, - request_signature: base64::engine::general_purpose::STANDARD.encode(req_sig), - jwt_secret: base64::engine::general_purpose::STANDARD.encode(jwt_secret), - forwarded_for: None, - ipdata_api_key: Some(String::from( - "eca677b284b3bac29eb72f5e496aa9047f26543605efe99ff2ce35c9", - )), - mfa_backup_code_count: 10, - stats_world_readable: true, - default_registration_token_expiration: 1000 * 60 * 60 * 24 * 7, - } - } -} diff --git a/types/config/types/sentry_configuration.rs b/types/config/types/sentry_configuration.rs deleted file mode 100644 index 256bab9..0000000 --- a/types/config/types/sentry_configuration.rs +++ /dev/null @@ -1,28 +0,0 @@ -use std::ffi::OsString; - -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct SentryConfiguration { - pub enabled: bool, - pub endpoint: String, - pub trace_sample_rate: f64, - pub environment: String, -} - -impl Default for SentryConfiguration { - fn default() -> Self { - Self { - enabled: false, - endpoint: String::from( - "https://241c6fb08adb469da1bb82522b25c99f@sentry.quartzinc.space/3", - ), - trace_sample_rate: 1.0, - environment: hostname::get() - .unwrap_or_else(|_| OsString::new()) - .to_string_lossy() - .to_string(), - } - } -} diff --git a/types/config/types/subconfigs/client/mod.rs b/types/config/types/subconfigs/client/mod.rs deleted file mode 100644 index 5d3d304..0000000 --- a/types/config/types/subconfigs/client/mod.rs +++ /dev/null @@ -1,17 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct ClientReleaseConfiguration { - pub use_local_release: bool, - pub upstream_version: String, -} - -impl Default for ClientReleaseConfiguration { - fn default() -> Self { - Self { - use_local_release: true, - upstream_version: String::from("0.0.264"), - } - } -} diff --git a/types/config/types/subconfigs/defaults/guild.rs b/types/config/types/subconfigs/defaults/guild.rs deleted file mode 100644 index 966c7af..0000000 --- a/types/config/types/subconfigs/defaults/guild.rs +++ /dev/null @@ -1,23 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct GuildDefaults { - pub max_presences: u64, - pub max_video_channel_users: u16, - pub afk_timeout: u16, - pub default_message_notifications: u8, - pub explicit_content_filter: u8, -} - -impl Default for GuildDefaults { - fn default() -> Self { - Self { - max_presences: 250_000, - max_video_channel_users: 200, - afk_timeout: 300, - default_message_notifications: 1, - explicit_content_filter: 0, - } - } -} diff --git a/types/config/types/subconfigs/defaults/mod.rs b/types/config/types/subconfigs/defaults/mod.rs deleted file mode 100644 index 56d877f..0000000 --- a/types/config/types/subconfigs/defaults/mod.rs +++ /dev/null @@ -1,2 +0,0 @@ -pub mod guild; -pub mod user; diff --git a/types/config/types/subconfigs/defaults/user.rs b/types/config/types/subconfigs/defaults/user.rs deleted file mode 100644 index 635d6d4..0000000 --- a/types/config/types/subconfigs/defaults/user.rs +++ /dev/null @@ -1,19 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct UserDefaults { - pub premium: bool, - pub premium_type: u8, - pub verified: bool, -} - -impl Default for UserDefaults { - fn default() -> Self { - Self { - premium: true, - premium_type: 2, - verified: true, - } - } -} diff --git a/types/config/types/subconfigs/email/mailgun.rs b/types/config/types/subconfigs/email/mailgun.rs deleted file mode 100644 index 636e462..0000000 --- a/types/config/types/subconfigs/email/mailgun.rs +++ /dev/null @@ -1,8 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct MailGunConfiguration { - pub api_key: Option, - pub domain: Option, -} diff --git a/types/config/types/subconfigs/email/mailjet.rs b/types/config/types/subconfigs/email/mailjet.rs deleted file mode 100644 index 4e505c1..0000000 --- a/types/config/types/subconfigs/email/mailjet.rs +++ /dev/null @@ -1,8 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct MailJetConfiguration { - pub api_key: Option, - pub api_secret: Option, -} diff --git a/types/config/types/subconfigs/email/mod.rs b/types/config/types/subconfigs/email/mod.rs deleted file mode 100644 index 21253fd..0000000 --- a/types/config/types/subconfigs/email/mod.rs +++ /dev/null @@ -1,4 +0,0 @@ -pub mod mailgun; -pub mod mailjet; -pub mod sendgrid; -pub mod smtp; diff --git a/types/config/types/subconfigs/email/sendgrid.rs b/types/config/types/subconfigs/email/sendgrid.rs deleted file mode 100644 index 879c719..0000000 --- a/types/config/types/subconfigs/email/sendgrid.rs +++ /dev/null @@ -1,7 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct SendGridConfiguration { - pub api_key: Option, -} diff --git a/types/config/types/subconfigs/email/smtp.rs b/types/config/types/subconfigs/email/smtp.rs deleted file mode 100644 index a02c66f..0000000 --- a/types/config/types/subconfigs/email/smtp.rs +++ /dev/null @@ -1,10 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] -pub struct SMTPConfiguration { - pub host: Option, - pub port: Option, - pub secure: bool, - pub username: Option, - pub password: Option, -} diff --git a/types/config/types/subconfigs/guild/autojoin.rs b/types/config/types/subconfigs/guild/autojoin.rs deleted file mode 100644 index 2d88d46..0000000 --- a/types/config/types/subconfigs/guild/autojoin.rs +++ /dev/null @@ -1,22 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::utils::Snowflake; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct AutoJoinConfiguration { - pub enabled: bool, - #[serde(skip_serializing_if = "Option::is_none")] - pub guilds: Option>, - pub can_leave: bool, -} - -impl Default for AutoJoinConfiguration { - fn default() -> Self { - Self { - enabled: true, - guilds: None, - can_leave: true, - } - } -} diff --git a/types/config/types/subconfigs/guild/discovery.rs b/types/config/types/subconfigs/guild/discovery.rs deleted file mode 100644 index 1e283b0..0000000 --- a/types/config/types/subconfigs/guild/discovery.rs +++ /dev/null @@ -1,21 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct DiscoverConfiguration { - pub show_all_guilds: bool, - pub use_recommendation: bool, - pub offset: u16, - pub limit: u16, -} - -impl Default for DiscoverConfiguration { - fn default() -> Self { - Self { - show_all_guilds: false, - use_recommendation: false, - offset: 0, - limit: 24, - } - } -} diff --git a/types/config/types/subconfigs/guild/mod.rs b/types/config/types/subconfigs/guild/mod.rs deleted file mode 100644 index e4d7dcf..0000000 --- a/types/config/types/subconfigs/guild/mod.rs +++ /dev/null @@ -1,2 +0,0 @@ -pub mod autojoin; -pub mod discovery; diff --git a/types/config/types/subconfigs/kafka/mod.rs b/types/config/types/subconfigs/kafka/mod.rs deleted file mode 100644 index 1ee4015..0000000 --- a/types/config/types/subconfigs/kafka/mod.rs +++ /dev/null @@ -1,7 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct KafkaBroker { - pub ip: String, - pub port: u16, -} diff --git a/types/config/types/subconfigs/limits/channel.rs b/types/config/types/subconfigs/limits/channel.rs deleted file mode 100644 index 03e46e5..0000000 --- a/types/config/types/subconfigs/limits/channel.rs +++ /dev/null @@ -1,19 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct ChannelLimits { - pub max_pins: u16, - pub max_topic: u16, - pub max_webhooks: u16, -} - -impl Default for ChannelLimits { - fn default() -> Self { - Self { - max_pins: 500, - max_topic: 1024, - max_webhooks: 100, - } - } -} diff --git a/types/config/types/subconfigs/limits/global.rs b/types/config/types/subconfigs/limits/global.rs deleted file mode 100644 index 87f9e1c..0000000 --- a/types/config/types/subconfigs/limits/global.rs +++ /dev/null @@ -1,41 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct GlobalRateLimit { - pub limit: u16, - pub window: u64, - pub enabled: bool, -} - -impl Default for GlobalRateLimit { - fn default() -> Self { - Self { - limit: 100, - window: 60 * 60 * 1000, - enabled: true, - } - } -} - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct GlobalRateLimits { - pub register: GlobalRateLimit, - pub send_message: GlobalRateLimit, -} - -impl Default for GlobalRateLimits { - fn default() -> Self { - Self { - register: GlobalRateLimit { - limit: 25, - ..Default::default() - }, - send_message: GlobalRateLimit { - limit: 200, - window: 60 * 1000, - ..Default::default() - }, - } - } -} diff --git a/types/config/types/subconfigs/limits/guild.rs b/types/config/types/subconfigs/limits/guild.rs deleted file mode 100644 index 6def5a0..0000000 --- a/types/config/types/subconfigs/limits/guild.rs +++ /dev/null @@ -1,23 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct GuildLimits { - pub max_roles: u16, - pub max_emojis: u16, - pub max_members: u64, - pub max_channels: u32, - pub max_channels_in_category: u32, -} - -impl Default for GuildLimits { - fn default() -> Self { - Self { - max_roles: 1000, - max_emojis: 20_000, - max_members: 25_000_000, - max_channels: 65_535, - max_channels_in_category: 65_535, - } - } -} diff --git a/types/config/types/subconfigs/limits/message.rs b/types/config/types/subconfigs/limits/message.rs deleted file mode 100644 index 9d368b9..0000000 --- a/types/config/types/subconfigs/limits/message.rs +++ /dev/null @@ -1,26 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct MessageLimits { - pub max_characters: u32, - #[serde(default)] - pub max_tts_characters: u32, - pub max_reactions: u32, - pub max_attachment_size: u64, - pub max_bulk_delete: u32, - pub max_embed_download_size: u64, -} - -impl Default for MessageLimits { - fn default() -> Self { - Self { - max_characters: 1048576, - max_tts_characters: 160, - max_reactions: 2048, - max_attachment_size: 1024 * 1024 * 1024, - max_bulk_delete: 1000, - max_embed_download_size: 1024 * 1024 * 5, - } - } -} diff --git a/types/config/types/subconfigs/limits/mod.rs b/types/config/types/subconfigs/limits/mod.rs deleted file mode 100644 index 4dbc2fa..0000000 --- a/types/config/types/subconfigs/limits/mod.rs +++ /dev/null @@ -1,7 +0,0 @@ -pub mod channel; -pub mod global; -pub mod guild; -pub mod message; -pub mod ratelimits; -pub mod rates; -pub mod user; diff --git a/types/config/types/subconfigs/limits/ratelimits/auth.rs b/types/config/types/subconfigs/limits/ratelimits/auth.rs deleted file mode 100644 index 3bfdccc..0000000 --- a/types/config/types/subconfigs/limits/ratelimits/auth.rs +++ /dev/null @@ -1,28 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::config::types::subconfigs::limits::ratelimits::RateLimitOptions; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct AuthRateLimit { - pub login: RateLimitOptions, - pub register: RateLimitOptions, -} - -impl Default for AuthRateLimit { - fn default() -> Self { - Self { - login: RateLimitOptions { - bot: None, - count: 5, - window: 60, - only_ip: false, - }, - register: RateLimitOptions { - bot: None, - count: 2, - window: 60 * 60 * 12, - only_ip: false, - }, - } - } -} diff --git a/types/config/types/subconfigs/limits/ratelimits/mod.rs b/types/config/types/subconfigs/limits/ratelimits/mod.rs deleted file mode 100644 index 66a2b78..0000000 --- a/types/config/types/subconfigs/limits/ratelimits/mod.rs +++ /dev/null @@ -1,14 +0,0 @@ -use serde::{Deserialize, Serialize}; - -pub mod auth; -pub mod route; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RateLimitOptions { - pub bot: Option, - pub count: u64, - pub window: u64, - #[serde(default)] - pub only_ip: bool, -} diff --git a/types/config/types/subconfigs/limits/ratelimits/route.rs b/types/config/types/subconfigs/limits/ratelimits/route.rs deleted file mode 100644 index 04e5a42..0000000 --- a/types/config/types/subconfigs/limits/ratelimits/route.rs +++ /dev/null @@ -1,37 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::config::types::subconfigs::limits::ratelimits::{auth::AuthRateLimit, RateLimitOptions}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct RouteRateLimit { - pub guild: RateLimitOptions, - pub webhook: RateLimitOptions, - pub channel: RateLimitOptions, - pub auth: AuthRateLimit, -} - -impl Default for RouteRateLimit { - fn default() -> Self { - Self { - guild: RateLimitOptions { - bot: None, - count: 5, - window: 5, - only_ip: false, - }, - webhook: RateLimitOptions { - bot: None, - count: 10, - window: 5, - only_ip: false, - }, - channel: RateLimitOptions { - bot: None, - count: 10, - window: 5, - only_ip: false, - }, - auth: AuthRateLimit::default(), - } - } -} diff --git a/types/config/types/subconfigs/limits/rates.rs b/types/config/types/subconfigs/limits/rates.rs deleted file mode 100644 index 3185b37..0000000 --- a/types/config/types/subconfigs/limits/rates.rs +++ /dev/null @@ -1,41 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::config::types::subconfigs::limits::ratelimits::{ - route::RouteRateLimit, RateLimitOptions, -}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct RateLimits { - pub enabled: bool, - pub ip: RateLimitOptions, - pub global: RateLimitOptions, - pub error: RateLimitOptions, - pub routes: RouteRateLimit, -} - -impl Default for RateLimits { - fn default() -> Self { - Self { - enabled: false, - ip: RateLimitOptions { - bot: None, - count: 500, - window: 5, - only_ip: false, - }, - global: RateLimitOptions { - bot: None, - count: 250, - window: 5, - only_ip: false, - }, - error: RateLimitOptions { - bot: None, - count: 10, - window: 5, - only_ip: false, - }, - routes: RouteRateLimit::default(), - } - } -} diff --git a/types/config/types/subconfigs/limits/user.rs b/types/config/types/subconfigs/limits/user.rs deleted file mode 100644 index e43b746..0000000 --- a/types/config/types/subconfigs/limits/user.rs +++ /dev/null @@ -1,19 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct UserLimits { - pub max_guilds: u64, - pub max_username: u16, - pub max_friends: u64, -} - -impl Default for UserLimits { - fn default() -> Self { - Self { - max_guilds: 1048576, - max_username: 32, - max_friends: 5000, - } - } -} diff --git a/types/config/types/subconfigs/mod.rs b/types/config/types/subconfigs/mod.rs deleted file mode 100644 index 4c85096..0000000 --- a/types/config/types/subconfigs/mod.rs +++ /dev/null @@ -1,9 +0,0 @@ -pub mod client; -pub mod defaults; -pub mod email; -pub mod guild; -pub mod kafka; -pub mod limits; -pub mod region; -pub mod register; -pub mod security; diff --git a/types/config/types/subconfigs/region/mod.rs b/types/config/types/subconfigs/region/mod.rs deleted file mode 100644 index e0b1800..0000000 --- a/types/config/types/subconfigs/region/mod.rs +++ /dev/null @@ -1,21 +0,0 @@ -use serde::{Deserialize, Serialize}; - - - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -pub struct LatLong { - pub latitude: f64, - pub longitude: f64, -} - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -pub struct Region { - pub id: String, - pub name: String, - pub endpoint: String, - pub location: Option, - pub vip: bool, - pub custom: bool, - #[serde(default)] - pub deprecated: bool, -} diff --git a/types/config/types/subconfigs/register/date_of_birth.rs b/types/config/types/subconfigs/register/date_of_birth.rs deleted file mode 100644 index 9c1bec1..0000000 --- a/types/config/types/subconfigs/register/date_of_birth.rs +++ /dev/null @@ -1,16 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct DateOfBirthConfiguration { - pub required: bool, - pub minimum: u8, -} - -impl Default for DateOfBirthConfiguration { - fn default() -> Self { - Self { - required: true, - minimum: 13, - } - } -} diff --git a/types/config/types/subconfigs/register/email.rs b/types/config/types/subconfigs/register/email.rs deleted file mode 100644 index ac99bfc..0000000 --- a/types/config/types/subconfigs/register/email.rs +++ /dev/null @@ -1,21 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct RegistrationEmailConfiguration { - pub required: bool, - pub allowlist: bool, - #[serde(default)] - pub blacklist: bool, - #[serde(default)] - pub domains: Vec, -} -impl Default for RegistrationEmailConfiguration { - fn default() -> Self { - Self { - required: false, - allowlist: false, - blacklist: true, - domains: Vec::new(), - } - } -} diff --git a/types/config/types/subconfigs/register/mod.rs b/types/config/types/subconfigs/register/mod.rs deleted file mode 100644 index ad92571..0000000 --- a/types/config/types/subconfigs/register/mod.rs +++ /dev/null @@ -1,7 +0,0 @@ -mod date_of_birth; -mod email; -mod password; - -pub use date_of_birth::DateOfBirthConfiguration; -pub use email::RegistrationEmailConfiguration; -pub use password::PasswordConfiguration; diff --git a/types/config/types/subconfigs/register/password.rs b/types/config/types/subconfigs/register/password.rs deleted file mode 100644 index 9247f7d..0000000 --- a/types/config/types/subconfigs/register/password.rs +++ /dev/null @@ -1,23 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct PasswordConfiguration { - pub required: bool, - pub min_length: u8, - pub min_numbers: u8, - pub min_upper_case: u8, - pub min_symbols: u8, -} - -impl Default for PasswordConfiguration { - fn default() -> Self { - Self { - required: false, - min_length: 8, - min_numbers: 2, - min_upper_case: 2, - min_symbols: 0, - } - } -} diff --git a/types/config/types/subconfigs/security/captcha.rs b/types/config/types/subconfigs/security/captcha.rs deleted file mode 100644 index 82bb517..0000000 --- a/types/config/types/subconfigs/security/captcha.rs +++ /dev/null @@ -1,27 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "lowercase")] -pub enum CaptchaService { - Recaptcha, - HCaptcha, -} - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct CaptchaConfiguration { - pub enabled: bool, - pub service: CaptchaService, - pub sitekey: Option, - pub secret: Option, -} - -impl Default for CaptchaConfiguration { - fn default() -> Self { - Self { - enabled: false, - service: CaptchaService::HCaptcha, - sitekey: None, - secret: None, - } - } -} diff --git a/types/config/types/subconfigs/security/mod.rs b/types/config/types/subconfigs/security/mod.rs deleted file mode 100644 index ceeb0d3..0000000 --- a/types/config/types/subconfigs/security/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod captcha; -mod twofactor; - -pub use captcha::{CaptchaConfiguration, CaptchaService}; -pub use twofactor::TwoFactorConfiguration; diff --git a/types/config/types/subconfigs/security/twofactor.rs b/types/config/types/subconfigs/security/twofactor.rs deleted file mode 100644 index 39a0373..0000000 --- a/types/config/types/subconfigs/security/twofactor.rs +++ /dev/null @@ -1,15 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct TwoFactorConfiguration { - pub generate_backup_codes: bool, -} - -impl Default for TwoFactorConfiguration { - fn default() -> Self { - Self { - generate_backup_codes: true, - } - } -} diff --git a/types/config/types/template_configuration.rs b/types/config/types/template_configuration.rs deleted file mode 100644 index 932670e..0000000 --- a/types/config/types/template_configuration.rs +++ /dev/null @@ -1,21 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct TemplateConfiguration { - pub enabled: bool, - pub allow_template_creation: bool, - pub allow_discord_templates: bool, - pub allow_raws: bool, -} - -impl Default for TemplateConfiguration { - fn default() -> Self { - Self { - enabled: true, - allow_template_creation: true, - allow_discord_templates: true, - allow_raws: true, - } - } -} diff --git a/types/entities/application.rs b/types/entities/application.rs deleted file mode 100644 index b838a5b..0000000 --- a/types/entities/application.rs +++ /dev/null @@ -1,140 +0,0 @@ - - -use crate::utils::Snowflake; -use bitflags::{bitflags, Flags}; -use serde::{Deserialize, Serialize}; -use serde_json::Value; -#[cfg(feature = "sqlx")] -use sqlx::FromRow; - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -#[cfg_attr(feature = "sqlx", derive(FromRow))] -pub struct Application { - pub id: Snowflake, - pub name: String, - pub icon: Option, - pub description: Option, - pub summary: Option, - #[cfg(feature = "sqlx")] - pub r#type: Option>, - #[cfg(not(feature = "sqlx"))] - pub r#type: Option, - pub hook: bool, - pub bot_public: bool, - pub bot_require_code_grant: bool, - pub verify_key: String, - pub owner_id: Snowflake, - pub flags: u64, - #[cfg(feature = "sqlx")] - pub redirect_uris: Option>>, - #[cfg(not(feature = "sqlx"))] - pub redirect_uris: Option>, - pub rpc_application_state: i64, - pub store_application_state: i64, - pub verification_state: i64, - pub interactions_endpoint_url: Option, - pub integration_public: bool, - pub integration_require_code_grant: bool, - pub discoverability_state: i64, - pub discovery_eligibility_flags: i64, - pub bot_user_id: Snowflake, - #[cfg(feature = "sqlx")] - pub tags: Option>>, - #[cfg(not(feature = "sqlx"))] - pub tags: Option>, - pub cover_image: Option, - #[cfg(feature = "sqlx")] - pub install_params: Option>, - #[cfg(not(feature = "sqlx"))] - pub install_params: Option, - pub terms_of_service_url: Option, - pub privacy_policy_url: Option, - pub team_id: Option, -} - -impl Application { - pub fn flags(&self) -> ApplicationFlags { - ApplicationFlags::from_bits(self.flags.to_owned()).unwrap() - } -} - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct InstallParams { - pub scopes: Vec, - pub permissions: String, -} - -bitflags! { - #[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)] - pub struct ApplicationFlags: u64 { - const APPLICATION_AUTO_MODERATION_RULE_CREATE_BADGE = 1 << 6; - const GATEWAY_PRESENCE = 1 << 12; - const GATEWAY_PRESENCE_LIMITED = 1 << 13; - const GATEWAY_GUILD_MEMBERS = 1 << 14; - const GATEWAY_GUILD_MEMBERS_LIMITED = 1 << 15; - const VERIFICATION_PENDING_GUILD_LIMIT = 1 << 16; - const EMBEDDED = 1 << 17; - const GATEWAY_MESSAGE_CONTENT = 1 << 18; - const GATEWAY_MESSAGE_CONTENT_LIMITED = 1 << 19; - const APPLICATION_COMMAND_BADGE = 1 << 23; - } -} - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -pub struct ApplicationCommand { - pub id: Snowflake, - pub application_id: Snowflake, - pub name: String, - pub description: String, - pub options: Vec, -} - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -pub struct ApplicationCommandOption { - pub r#type: ApplicationCommandOptionType, - pub name: String, - pub description: String, - pub required: bool, - pub choices: Vec, - pub options: Vec, -} - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -pub struct ApplicationCommandOptionChoice { - pub name: String, - pub value: Value, -} - -#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)] -pub enum ApplicationCommandOptionType { - #[serde(rename = "SUB_COMMAND")] - SubCommand = 1, - #[serde(rename = "SUB_COMMAND_GROUP")] - SubCommandGroup = 2, - #[serde(rename = "STRING")] - String = 3, - #[serde(rename = "INTEGER")] - Integer = 4, - #[serde(rename = "BOOLEAN")] - Boolean = 5, - #[serde(rename = "USER")] - User = 6, - #[serde(rename = "CHANNEL")] - Channel = 7, - #[serde(rename = "ROLE")] - Role = 8, -} - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -pub struct ApplicationCommandInteractionData { - pub id: Snowflake, - pub name: String, - pub options: Vec, -} - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -pub struct ApplicationCommandInteractionDataOption { - pub name: String, - pub value: Value, - pub options: Vec, -} diff --git a/types/entities/attachment.rs b/types/entities/attachment.rs deleted file mode 100644 index 56384f7..0000000 --- a/types/entities/attachment.rs +++ /dev/null @@ -1,113 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::utils::Snowflake; - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -pub struct Attachment { - pub id: Snowflake, - pub filename: String, - pub description: Option, - pub content_type: Option, - pub size: u64, - pub url: String, - pub proxy_url: String, - pub height: Option, - pub width: Option, - pub message_id: Snowflake, - pub ephemeral: Option, - pub duration_secs: Option, - pub waveform: Option, - #[serde(skip_serializing)] - pub content: Vec, -} - -#[derive(Debug, Serialize, Deserialize, Clone)] - -pub struct PartialDiscordFileAttachment { - pub id: Option, - pub filename: String, - pub description: Option, - pub content_type: Option, - pub size: Option, - pub url: Option, - pub proxy_url: Option, - pub height: Option, - pub width: Option, - pub ephemeral: Option, - pub duration_secs: Option, - pub waveform: Option, - #[serde(skip_serializing)] - pub content: Vec, -} - -impl PartialDiscordFileAttachment { - /** - Moves `self.content` out of `self` and returns it. - # Returns - Vec - */ - pub fn move_content(self) -> (Vec, 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) - } - - 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) - } - - pub fn move_content_type(self) -> (Option, 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); - } -} diff --git a/types/entities/channel.rs b/types/entities/channel.rs deleted file mode 100644 index 71c65a1..0000000 --- a/types/entities/channel.rs +++ /dev/null @@ -1,116 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::{ - entities::{GuildMember, User}, - utils::Snowflake, -}; - -#[derive(Default, Debug, Serialize, Deserialize, Clone, PartialEq, Eq)] -pub struct Channel { - pub id: Snowflake, - #[serde(rename = "type")] - pub channel_type: ChannelType, - pub guild_id: Option, - pub position: Option, - pub permission_overwrites: Option>, - pub name: Option, - pub topic: Option, - pub nsfw: Option, - pub last_message_id: Option, - pub bitrate: Option, - pub user_limit: Option, - pub rate_limit_per_user: Option, - pub recipients: Option>, - pub icon: Option, - pub owner_id: Option, - pub application_id: Option, - pub parent_id: Option, - pub last_pin_timestamp: Option, - pub rtc_region: Option, - pub video_quality_mode: Option, - pub message_count: Option, - pub member_count: Option, - pub thread_metadata: Option, - pub member: Option, - pub default_auto_archive_duration: Option, - pub permissions: Option, - pub flags: Option, - pub total_message_sent: Option, - pub available_tags: Option>, - pub applied_tags: Option>, - pub default_reaction_emoji: Option, - pub default_thread_rate_limit_per_user: Option, - pub default_sort_order: Option, - pub default_forum_layout: Option, -} - -#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)] -pub struct Tag { - pub id: u64, - pub name: String, - pub moderated: bool, - pub emoji_id: Option, - pub emoji_name: Option, -} - -#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)] -pub struct PermissionOverwrite { - pub id: String, - #[serde(rename = "type")] - pub overwrite_type: u8, - pub allow: String, - pub deny: String, -} - -#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)] -pub struct ThreadMetadata { - pub archived: bool, - pub auto_archive_duration: i32, - pub archive_timestamp: String, - pub locked: bool, - pub invitable: Option, - pub create_timestamp: Option, -} - -#[derive(Default, Debug, Deserialize, Serialize, Clone, PartialEq, Eq)] -pub struct ThreadMember { - pub id: Option, - pub user_id: Option, - pub join_timestamp: Option, - pub flags: Option, - pub member: Option, -} - -#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)] -pub struct DefaultReaction { - pub emoji_id: Option, - pub emoji_name: Option, -} - -#[derive(Default, Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)] -#[serde(rename_all = "SCREAMING_SNAKE_CASE")] -#[repr(i32)] -pub enum ChannelType { - #[default] - GuildText = 0, - Dm = 1, - GuildVoice = 2, - GroupDm = 3, - GuildCategory = 4, - GuildNews = 5, - GuildStore = 6, - Encrypted = 7, - EncryptedThreads = 8, - Transactional = 9, - GuildNewsThread = 10, - GuildPublicThread = 11, - GuildPrivateThread = 12, - GuildStageVoice = 13, - Directory = 14, - GuildForum = 15, - TicketTracker = 33, - Kanban = 34, - VoicelessWhiteboard = 35, - CustomStart = 64, - Unhandled = 255, -} diff --git a/types/entities/config.rs b/types/entities/config.rs deleted file mode 100644 index 25b1ef1..0000000 --- a/types/entities/config.rs +++ /dev/null @@ -1,34 +0,0 @@ -use serde::{Deserialize, Serialize}; -use serde_json::Value; -#[cfg(feature = "sqlx")] -use sqlx::FromRow; - -#[derive(Debug, Serialize, Deserialize)] -#[cfg_attr(feature = "sqlx", derive(FromRow))] -pub struct ConfigEntity { - pub key: String, - pub value: Option, -} - -impl ConfigEntity { - pub fn as_string(&self) -> Option { - let Some(v) = self.value.as_ref() else { - return None; - }; - Some(v.as_str().expect("value is not a string").to_string()) - } - - pub fn as_bool(&self) -> Option { - let Some(v) = self.value.as_ref() else { - return None; - }; - Some(v.as_bool().expect("value is not a boolean")) - } - - pub fn as_int(&self) -> Option { - let Some(v) = self.value.as_ref() else { - return None; - }; - Some(v.as_i64().expect("value is not a number")) - } -} diff --git a/types/entities/emoji.rs b/types/entities/emoji.rs deleted file mode 100644 index 2698607..0000000 --- a/types/entities/emoji.rs +++ /dev/null @@ -1,15 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::entities::User; - -#[derive(Debug, Deserialize, Serialize, Default, Clone)] -pub struct Emoji { - pub id: Option, - pub name: Option, - pub roles: Option>, - pub user: Option, - pub require_colons: Option, - pub managed: Option, - pub animated: Option, - pub available: Option, -} diff --git a/types/entities/guild.rs b/types/entities/guild.rs deleted file mode 100644 index 9b2abe7..0000000 --- a/types/entities/guild.rs +++ /dev/null @@ -1,117 +0,0 @@ -use chrono::{DateTime, Utc}; -use serde::{Deserialize, Serialize}; - -use crate::{ - entities::{Channel, Emoji, GuildTemplate, RoleObject, Sticker, User, VoiceState, Webhook}, - interfaces::WelcomeScreenObject, - utils::Snowflake, -}; - -/// See https://discord.com/developers/docs/resources/guild -#[derive(Serialize, Deserialize, Debug, Default, Clone)] -pub struct Guild { - pub id: Snowflake, - pub name: String, - pub icon: Option, - pub icon_hash: Option, - pub splash: Option, - pub discovery_splash: Option, - pub owner: Option, - pub owner_id: Option, - pub permissions: Option, - pub afk_channel_id: Option, - pub afk_timeout: Option, - pub widget_enabled: Option, - pub widget_channel_id: Option, - pub widget_channel: Option, - pub verification_level: Option, - pub default_message_notifications: Option, - pub explicit_content_filter: Option, - pub roles: Vec, - pub emojis: Vec, - pub features: Vec, - pub application_id: Option, - pub system_channel_id: Option, - pub system_channel_flags: Option, - pub rules_channel_id: Option, - pub rules_channel: Option, - pub max_presences: Option, - pub max_members: Option, - pub vanity_url_code: Option, - pub description: Option, - pub banner: Option, - pub premium_tier: Option, - pub premium_subscription_count: Option, - pub preferred_locale: Option, - pub public_updates_channel_id: Option, - pub public_updates_channel: Option, - pub max_video_channel_users: Option, - pub max_stage_video_channel_users: Option, - pub approximate_member_count: Option, - pub approximate_presence_count: Option, - pub member_count: Option, - pub presence_count: Option, - pub welcome_screen: Option, - pub nsfw_level: u8, - pub nsfw: bool, - pub stickers: Option>, - pub premium_progress_bar_enabled: Option, - pub joined_at: String, - pub afk_channel: Option, - pub bans: Option>, - pub primary_category_id: Option, - pub large: Option, - pub channels: Option>, - pub template_id: Option, - pub template: Option, - pub invites: Option>, - pub voice_states: Option>, - pub webhooks: Option>, - pub mfa_level: Option, - pub region: Option, - pub unavailable: bool, - pub parent: Option, -} - -/// See https://docs.spacebar.chat/routes/#get-/guilds/-guild_id-/bans/-user- -#[derive(Serialize, Deserialize, Debug, Default, Clone)] -pub struct GuildBan { - pub id: Snowflake, - pub user_id: Snowflake, - pub guild_id: Snowflake, - pub executor_id: Snowflake, - pub reason: Option, -} - -/// See https://docs.spacebar.chat/routes/#cmp--schemas-invite -#[derive(Serialize, Deserialize, Debug, Default, Clone)] -pub struct GuildInvite { - pub code: String, - pub temporary: Option, - pub uses: Option, - pub max_uses: Option, - pub max_age: Option, - pub created_at: DateTime, - pub expires_at: Option>, - pub guild_id: String, - pub guild: Option, - pub channel_id: String, - pub channel: Option, - pub inviter_id: Option, - pub inviter: Option, - pub target_user_id: Option, - pub target_user: Option, - pub target_user_type: Option, - pub vanity_url: Option, -} - -#[derive(Serialize, Deserialize, Debug, Default)] -pub struct UnavailableGuild { - id: String, - unavailable: bool, -} - -#[derive(Serialize, Deserialize, Debug, Default, Clone)] -pub struct GuildCreateResponse { - pub id: String, -} diff --git a/types/entities/guild_member.rs b/types/entities/guild_member.rs deleted file mode 100644 index 272baa7..0000000 --- a/types/entities/guild_member.rs +++ /dev/null @@ -1,19 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::entities::User; - -#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)] -pub struct GuildMember { - pub user: Option, - pub nick: Option, - pub avatar: Option, - pub roles: Vec, - pub joined_at: String, - pub premium_since: Option, - pub deaf: bool, - pub mute: bool, - pub flags: i32, - pub pending: Option, - pub permissions: Option, - pub communication_disabled_until: Option, -} diff --git a/types/entities/integration.rs b/types/entities/integration.rs deleted file mode 100644 index 95b0de6..0000000 --- a/types/entities/integration.rs +++ /dev/null @@ -1,36 +0,0 @@ -use chrono::{DateTime, Utc}; -use serde::{Deserialize, Serialize}; - -use crate::{ - entities::{Application, User}, - utils::Snowflake, -}; - -#[derive(Default, Debug, Deserialize, Serialize, Clone)] -/// See https://discord.com/developers/docs/resources/guild#integration-object-integration-structure -pub struct Integration { - pub id: Snowflake, - pub name: String, - #[serde(rename = "type")] - pub integration_type: String, - pub enabled: bool, - pub syncing: Option, - pub role_id: Option, - pub enabled_emoticons: Option, - pub expire_behaviour: Option, - pub expire_grace_period: Option, - pub user: Option, - pub account: IntegrationAccount, - pub synced_at: Option>, - pub subscriber_count: Option, - pub revoked: Option, - pub application: Option, - pub scopes: Option>, -} - -#[derive(Default, Debug, Deserialize, Serialize, Clone)] -/// See https://discord.com/developers/docs/resources/guild#integration-account-object-integration-account-structure -pub struct IntegrationAccount { - pub id: String, - pub name: String, -} diff --git a/types/entities/message.rs b/types/entities/message.rs deleted file mode 100644 index 914affa..0000000 --- a/types/entities/message.rs +++ /dev/null @@ -1,185 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::{ - entities::{ - Application, Attachment, Channel, Emoji, GuildMember, RoleSubscriptionData, Sticker, - StickerItem, User, - }, - utils::Snowflake, -}; - -#[derive(Debug, Serialize, Deserialize, Default)] -pub struct Message { - id: Snowflake, - pub channel_id: Snowflake, - author: User, - content: String, - timestamp: String, - edited_timestamp: Option, - tts: bool, - mention_everyone: bool, - mentions: Vec, - mention_roles: Vec, - mention_channels: Option>, - pub attachments: Vec, - embeds: Vec, - reactions: Option>, - nonce: Option, - pinned: bool, - webhook_id: Option, - #[serde(rename = "type")] - message_type: i32, - activity: Option, - application: Option, - application_id: Option, - message_reference: Option, - flags: Option, - referenced_message: Option>, - interaction: Option, - thread: Option, - components: Option>, - sticker_items: Option>, - stickers: Option>, - position: Option, - role_subscription_data: Option, -} - -#[derive(Debug, Serialize, Deserialize)] -pub struct MessageReference { - pub message_id: Snowflake, - pub channel_id: Snowflake, - pub guild_id: Option, - pub fail_if_not_exists: Option, -} - -#[derive(Debug, Deserialize, Serialize)] -pub struct MessageInteraction { - pub id: Snowflake, - #[serde(rename = "type")] - pub interaction_type: u8, - pub name: String, - pub user: User, - pub member: Option, -} - -#[derive(Debug, Serialize, Deserialize)] -pub struct AllowedMention { - parse: Vec, - roles: Vec, - users: Vec, - replied_user: bool, -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(rename_all = "snake_case")] -pub enum AllowedMentionType { - Roles, - Users, - Everyone, -} - -#[derive(Debug, Serialize, Deserialize)] -struct ChannelMention { - id: Snowflake, - guild_id: Snowflake, - #[serde(rename = "type")] - channel_type: i32, - name: String, -} - -#[derive(Debug, Serialize, Deserialize)] -pub struct Embed { - title: Option, - #[serde(rename = "type")] - embed_type: Option, - description: Option, - url: Option, - timestamp: Option, - color: Option, - footer: Option, - image: Option, - thumbnail: Option, - video: Option, - provider: Option, - author: Option, - fields: Option>, -} - -#[derive(Debug, Serialize, Deserialize)] -struct EmbedFooter { - text: String, - icon_url: Option, - proxy_icon_url: Option, -} - -#[derive(Debug, Serialize, Deserialize)] -struct EmbedImage { - url: String, - proxy_url: String, - height: Option, - width: Option, -} - -#[derive(Debug, Serialize, Deserialize)] -struct EmbedThumbnail { - url: String, - proxy_url: Option, - height: Option, - width: Option, -} - -#[derive(Debug, Serialize, Deserialize)] -struct EmbedVideo { - url: Option, - proxy_url: Option, - height: Option, - width: Option, -} - -#[derive(Debug, Serialize, Deserialize)] -struct EmbedProvider { - name: Option, - url: Option, -} - -#[derive(Debug, Serialize, Deserialize)] -struct EmbedAuthor { - name: String, - url: Option, - icon_url: Option, - proxy_icon_url: Option, -} - -#[derive(Debug, Serialize, Deserialize)] - -struct EmbedField { - name: String, - value: String, - inline: Option, -} - -#[derive(Debug, Serialize, Deserialize)] -pub struct Reaction { - pub count: i32, - pub me: bool, - pub emoji: Emoji, -} - -#[derive(Debug, Serialize, Deserialize)] -pub enum Component { - ActionRow = 1, - Button = 2, - StringSelect = 3, - TextInput = 4, - UserSelect = 5, - RoleSelect = 6, - MentionableSelect = 7, - ChannelSelect = 8, -} - -#[derive(Debug, Serialize, Deserialize)] -pub struct MessageActivity { - #[serde(rename = "type")] - pub activity_type: i64, - pub party_id: Option, -} diff --git a/types/entities/mod.rs b/types/entities/mod.rs deleted file mode 100644 index 006aac1..0000000 --- a/types/entities/mod.rs +++ /dev/null @@ -1,37 +0,0 @@ -mod application; -mod attachment; -mod channel; -mod config; -mod emoji; -mod guild; -mod guild_member; -mod integration; -mod message; -mod role; -mod security_key; -mod sticker; -mod team; -mod template; -mod user; -mod user_settings; -mod voice_state; -mod webhook; - -pub use application::*; -pub use attachment::*; -pub use channel::*; -pub use config::*; -pub use emoji::*; -pub use guild::*; -pub use guild_member::*; -pub use integration::*; -pub use message::*; -pub use role::*; -pub use security_key::*; -pub use sticker::*; -pub use team::*; -pub use template::*; -pub use user::*; -pub use user_settings::*; -pub use voice_state::*; -pub use webhook::*; diff --git a/types/entities/role.rs b/types/entities/role.rs deleted file mode 100644 index f440775..0000000 --- a/types/entities/role.rs +++ /dev/null @@ -1,28 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::utils::Snowflake; - -#[derive(Serialize, Deserialize, Debug, Default, Clone)] -/// See https://discord.com/developers/docs/topics/permissions#role-object -pub struct RoleObject { - pub id: Snowflake, - pub name: String, - pub color: f64, - pub hoist: bool, - pub icon: Option, - pub unicode_emoji: Option, - pub position: u16, - pub permissions: String, - pub managed: bool, - pub mentionable: bool, - // to:do add role tags https://discord.com/developers/docs/topics/permissions#role-object-role-tags-structure - //pub tags: Option -} - -#[derive(Debug, Serialize, Deserialize)] -pub struct RoleSubscriptionData { - pub role_subscription_listing_id: Snowflake, - pub tier_name: String, - pub total_months_subscribed: u32, - pub is_renewal: bool, -} diff --git a/types/entities/security_key.rs b/types/entities/security_key.rs deleted file mode 100644 index 9eaa378..0000000 --- a/types/entities/security_key.rs +++ /dev/null @@ -1,26 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::utils::Snowflake; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct SecurityKey { - pub id: String, - pub user_id: String, - pub key_id: String, - pub public_key: String, - pub counter: u64, - pub name: String, -} - -impl Default for SecurityKey { - fn default() -> Self { - Self { - id: Snowflake::generate().to_string(), - user_id: String::new(), - key_id: String::new(), - public_key: String::new(), - counter: 0, - name: String::new(), - } - } -} diff --git a/types/entities/sticker.rs b/types/entities/sticker.rs deleted file mode 100644 index c3a8950..0000000 --- a/types/entities/sticker.rs +++ /dev/null @@ -1,27 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::{entities::User, utils::Snowflake}; - -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct Sticker { - pub id: Snowflake, - pub pack_id: Option, - pub name: String, - pub description: Option, - pub tags: String, - pub asset: Option, - #[serde(rename = "type")] - pub sticker_type: u8, - pub format_type: u8, - pub available: Option, - pub guild_id: Option, - pub user: Option, - pub sort_value: Option, -} - -#[derive(Debug, Serialize, Deserialize)] -pub struct StickerItem { - pub id: Snowflake, - pub name: String, - pub format_type: u8, -} diff --git a/types/entities/team.rs b/types/entities/team.rs deleted file mode 100644 index 5bcf863..0000000 --- a/types/entities/team.rs +++ /dev/null @@ -1,20 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::entities::User; - -#[derive(Debug, Deserialize, Serialize, Clone)] -pub struct Team { - pub icon: Option, - pub id: u64, - pub members: Vec, - pub name: String, - pub owner_user_id: u64, -} - -#[derive(Debug, Deserialize, Serialize, Clone)] -pub struct TeamMember { - pub membership_state: u8, - pub permissions: Vec, - pub team_id: u64, - pub user: User, -} diff --git a/types/entities/template.rs b/types/entities/template.rs deleted file mode 100644 index d640320..0000000 --- a/types/entities/template.rs +++ /dev/null @@ -1,24 +0,0 @@ -use chrono::{DateTime, Utc}; -use serde::{Deserialize, Serialize}; - -use crate::{ - entities::{Guild, User}, - utils::Snowflake, -}; - -/// See https://docs.spacebar.chat/routes/#cmp--schemas-template -#[derive(Serialize, Deserialize, Debug, Default, Clone)] -pub struct GuildTemplate { - pub code: String, - pub name: String, - pub description: Option, - pub usage_count: Option, - pub creator_id: Snowflake, - pub creator: User, - pub created_at: DateTime, - pub updated_at: DateTime, - pub source_guild_id: String, - pub source_guild: Vec, // Unsure how a {recursive: Guild} looks like, might be a Vec? - pub serialized_source_guild: Vec, - id: Snowflake, -} diff --git a/types/entities/user.rs b/types/entities/user.rs deleted file mode 100644 index ce3563c..0000000 --- a/types/entities/user.rs +++ /dev/null @@ -1,112 +0,0 @@ -use chrono::{DateTime, Utc}; -use serde::{Deserialize, Serialize}; -use serde_json::{Map, Value}; -#[cfg(feature = "sqlx")] -use sqlx::{FromRow, Type}; - -use crate::{ - errors::Error, - utils::Snowflake, //util::{email::adjust_email, entities::user_setting::UserSettings}, -}; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)] -#[cfg_attr(feature = "sqlx", derive(Type))] -pub struct UserData { - pub valid_tokens_since: DateTime, - pub hash: Option, -} - -#[derive(Serialize, Deserialize, Debug, Default, Clone)] -pub struct User { - pub id: String, - username: String, - discriminator: String, - avatar: Option, - bot: bool, - system: Option, - mfa_enabled: Option, - accent_color: Option, - locale: Option, - verified: Option, - email: Option, - flags: String, - premium_since: Option, - premium_type: i8, - pronouns: Option, - public_flags: Option, - banner: Option, - bio: String, - theme_colors: Option>, - phone: Option, - nsfw_allowed: bool, - premium: bool, - purchased_flags: i32, - premium_usage_flags: i32, - disabled: Option, -} - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -pub struct User { - pub id: Snowflake, - pub username: String, - pub discriminator: String, - pub avatar: Option, - pub accent_color: Option, - pub banner: Option, - pub theme_colors: Option>, - pub pronouns: Option, - pub bot: bool, - pub bio: String, - pub premium_type: u8, - pub premium_since: Option>, - pub public_flags: u16, -} - -impl From for PublicUser { - fn from(value: User) -> Self { - Self { - id: value.id, - username: value.username, - discriminator: value.discriminator, - avatar: value.avatar, - accent_color: value.accent_color, - banner: value.banner, - theme_colors: value.theme_colors, - pronouns: value.pronouns, - bot: value.bot, - bio: value.bio, - premium_type: value.premium_type, - premium_since: value.premium_since, - public_flags: value.public_flags, - } - } -} - -const CUSTOM_USER_FLAG_OFFSET: u64 = 1 << 32; - -bitflags::bitflags! { - #[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)] - #[cfg_attr(feature = "sqlx", derive(Type))] - pub struct UserFlags: u64 { - const DISCORD_EMPLOYEE = 1 << 0; - const PARTNERED_SERVER_OWNER = 1 << 1; - const HYPESQUAD_EVENTS = 1 << 2; - const BUGHUNTER_LEVEL_1 =1 << 3; - const MFA_SMS = 1 << 4; - const PREMIUM_PROMO_DISMISSED = 1 << 5; - const HOUSE_BRAVERY = 1 << 6; - const HOUSE_BRILLIANCE = 1 << 7; - const HOUSE_BALANCE = 1 << 8; - const EARLY_SUPPORTER = 1 << 9; - const TEAM_USER = 1 << 10; - const TRUST_AND_SAFETY = 1 << 11; - const SYSTEM = 1 << 12; - const HAS_UNREAD_URGENT_MESSAGES = 1 << 13; - const BUGHUNTER_LEVEL_2 = 1 << 14; - const UNDERAGE_DELETED = 1 << 15; - const VERIFIED_BOT = 1 << 16; - const EARLY_VERIFIED_BOT_DEVELOPER = 1 << 17; - const CERTIFIED_MODERATOR = 1 << 18; - const BOT_HTTP_INTERACTIONS = 1 << 19; - } -} diff --git a/types/entities/user_settings.rs b/types/entities/user_settings.rs deleted file mode 100644 index c4adaee..0000000 --- a/types/entities/user_settings.rs +++ /dev/null @@ -1,133 +0,0 @@ -use chrono::{serde::ts_milliseconds_option, Utc}; -use serde::{Deserialize, Serialize}; - -use crate::utils::Snowflake; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)] -#[serde(rename_all = "lowercase")] -pub enum UserStatus { - #[default] - Online, - Offline, - Dnd, - Idle, - Invisible, -} - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)] -#[serde(rename_all = "lowercase")] -pub enum UserTheme { - #[default] - Dark, - Light, -} - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct UserSettings { - #[serde(skip_serializing)] - pub index: String, // Database relevance only - pub afk_timeout: u16, - pub allow_accessibility_detection: bool, - pub animate_emoji: bool, - pub animate_stickers: u8, - pub contact_sync_enabled: bool, - pub convert_emoticons: bool, - pub custom_status: Option, - pub default_guilds_restricted: bool, - pub detect_platform_accounts: bool, - pub developer_mode: bool, - pub disable_games_tab: bool, - pub enable_tts_command: bool, - pub explicit_content_filter: u8, - pub friend_source_flags: FriendSourceFlags, - pub gateway_connected: bool, - pub gif_auto_play: bool, - pub guild_folders: Vec, - pub guild_positions: Vec, - pub inline_attachment_media: bool, - pub inline_embed_media: bool, - pub locale: String, - pub message_display_compact: bool, - pub native_phone_integration_enabled: bool, - pub render_embeds: bool, - pub render_reactions: bool, - pub restricted_guilds: Vec, - pub show_current_game: bool, - pub status: UserStatus, - pub stream_notifications_enabled: bool, - pub theme: UserTheme, - pub timezone_offset: i16, -} - -impl Default for UserSettings { - fn default() -> Self { - Self { - index: Snowflake::generate().to_string(), - afk_timeout: 3600, - allow_accessibility_detection: true, - animate_emoji: true, - animate_stickers: 0, - contact_sync_enabled: false, - convert_emoticons: false, - custom_status: None, - default_guilds_restricted: false, - detect_platform_accounts: false, - developer_mode: true, - disable_games_tab: true, - enable_tts_command: false, - explicit_content_filter: 0, - friend_source_flags: FriendSourceFlags::default(), - gateway_connected: false, - gif_auto_play: false, - guild_folders: Vec::new(), - guild_positions: Vec::new(), - inline_attachment_media: true, - inline_embed_media: true, - locale: "en-US".to_string(), - message_display_compact: false, - native_phone_integration_enabled: true, - render_embeds: true, - render_reactions: true, - restricted_guilds: Vec::new(), - show_current_game: true, - status: UserStatus::Online, - stream_notifications_enabled: false, - theme: UserTheme::Dark, - timezone_offset: 0, - } - } -} - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct CustomStatus { - pub emoji_id: Option, - pub emoji_name: Option, - #[serde(with = "ts_milliseconds_option")] - pub expires_at: Option>, - pub text: Option, -} - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct FriendSourceFlags { - pub all: bool, -} - -impl Default for FriendSourceFlags { - fn default() -> Self { - Self { all: true } - } -} - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct GuildFolder { - pub color: u32, - pub guild_ids: Vec, - pub id: u16, - pub name: String, -} - -#[derive(Debug, Serialize, Deserialize)] -pub struct LoginResult { - pub token: String, - pub settings: UserSettings, -} diff --git a/types/entities/voice_state.rs b/types/entities/voice_state.rs deleted file mode 100644 index 79ee1cc..0000000 --- a/types/entities/voice_state.rs +++ /dev/null @@ -1,30 +0,0 @@ -use chrono::{DateTime, Utc}; -use serde::{Deserialize, Serialize}; - -use crate::{ - entities::{Channel, Guild, GuildMember, User}, - utils::Snowflake, -}; - -/// See https://docs.spacebar.chat/routes/#cmp--schemas-voicestate -#[derive(Serialize, Deserialize, Debug, Default, Clone)] -pub struct VoiceState { - pub guild_id: Snowflake, - pub guild: Option, - pub channel_id: Snowflake, - pub channel: Option, - pub user_id: Snowflake, - pub user: Option, - pub member: Option, - pub session_id: Snowflake, - pub token: String, - pub deaf: bool, - pub mute: bool, - pub self_deaf: bool, - pub self_mute: bool, - pub self_stream: Option, - pub self_video: bool, - pub suppress: bool, - pub request_to_speak_timestamp: Option>, - pub id: Snowflake, -} diff --git a/types/entities/webhook.rs b/types/entities/webhook.rs deleted file mode 100644 index e690a72..0000000 --- a/types/entities/webhook.rs +++ /dev/null @@ -1,32 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::{ - entities::{Application, Channel, Guild, User}, - utils::Snowflake, -}; - -/// See https://docs.spacebar.chat/routes/#cmp--schemas-webhook -#[derive(Serialize, Deserialize, Debug, Default, Clone)] -pub struct Webhook { - #[serde(rename = "type")] - pub webhook_type: i32, - pub name: String, - pub avatar: String, - pub token: String, - pub guild_id: Snowflake, - #[serde(skip_serializing_if = "Option::is_none")] - pub guild: Option, - pub channel_id: Snowflake, - #[serde(skip_serializing_if = "Option::is_none")] - pub channel: Option, - pub application_id: Snowflake, - #[serde(skip_serializing_if = "Option::is_none")] - pub application: Option, - pub user_id: Snowflake, - #[serde(skip_serializing_if = "Option::is_none")] - pub user: Option, - pub source_guild_id: Snowflake, - #[serde(skip_serializing_if = "Option::is_none")] - pub source_guild: Option, - pub id: Snowflake, -} diff --git a/types/errors.rs b/types/errors.rs deleted file mode 100644 index 63f6ceb..0000000 --- a/types/errors.rs +++ /dev/null @@ -1,54 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, thiserror::Error)] -pub enum Error { - #[cfg(feature = "sqlx")] - #[error("SQLX error: {0}")] - SQLX(#[from] sqlx::Error), - - #[error("serde: {0}")] - Serde(#[from] serde_json::Error), - - #[error(transparent)] - IO(#[from] std::io::Error), - - #[error(transparent)] - FieldFormat(#[from] FieldFormatError), -} - -#[derive(Debug, PartialEq, Eq, thiserror::Error)] -pub enum FieldFormatError { - #[error("Password must be between 1 and 72 characters.")] - PasswordError, - #[error("Username must be between 2 and 32 characters.")] - UsernameError, - #[error("Consent must be 'true' to register.")] - ConsentError, - #[error("The provided email address is in an invalid format.")] - EmailError, -} - -#[derive(Serialize, Deserialize, Debug)] -pub struct ErrorResponse { - pub code: i32, - pub message: String, - pub errors: IntermittentError, -} - -#[derive(Serialize, Deserialize, Debug)] -pub struct IntermittentError { - #[serde(flatten)] - pub errors: std::collections::HashMap, -} - -#[derive(Serialize, Deserialize, Debug, Default)] -pub struct ErrorField { - #[serde(default)] - pub _errors: Vec, -} - -#[derive(Serialize, Deserialize, Debug)] -pub struct APIError { - pub message: String, - pub code: String, -} diff --git a/types/events/channel.rs b/types/events/channel.rs deleted file mode 100644 index 19e4238..0000000 --- a/types/events/channel.rs +++ /dev/null @@ -1,41 +0,0 @@ -use chrono::{DateTime, Utc}; -use serde::{Deserialize, Serialize}; -use crate::entities::Channel; -use crate::events::WebSocketEvent; - -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#channel-pins-update -pub struct ChannelPinsUpdate { - pub guild_id: Option, - pub channel_id: String, - pub last_pin_timestamp: Option>, -} - -impl WebSocketEvent for ChannelPinsUpdate {} - -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#channel-create -/// Not directly serialized, as the inner payload is a channel object -pub struct ChannelCreate { - pub channel: Channel, -} - -impl WebSocketEvent for ChannelCreate {} - -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#channel-update -/// Not directly serialized, as the inner payload is a channel object -pub struct ChannelUpdate { - pub channel: Channel, -} - -impl WebSocketEvent for ChannelUpdate {} - -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#channel-delete -/// Not directly serialized, as the inner payload is a channel object -pub struct ChannelDelete { - pub channel: Channel, -} - -impl WebSocketEvent for ChannelDelete {} \ No newline at end of file diff --git a/types/events/guild.rs b/types/events/guild.rs deleted file mode 100644 index 3b17861..0000000 --- a/types/events/guild.rs +++ /dev/null @@ -1,41 +0,0 @@ -use serde::{Deserialize, Serialize}; -use crate::entities::{Guild, UnavailableGuild, User}; -use crate::events::WebSocketEvent; - -#[derive(Debug, Deserialize, Serialize, Default)] -/// See https://discord.com/developers/docs/topics/gateway-events#guild-create -/// This one is particularly painful, it can be a Guild object with extra field or an unavailbile guild object -pub struct GuildCreate { - pub d: GuildCreateDataOption, -} - -#[derive(Debug, Deserialize, Serialize)] -pub enum GuildCreateDataOption { - UnavailableGuild(UnavailableGuild), - Guild(Guild), -} - -impl Default for GuildCreateDataOption { - fn default() -> Self { - GuildCreateDataOption::UnavailableGuild(UnavailableGuild::default()) - } -} -impl WebSocketEvent for GuildCreate {} - -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#guild-ban-add-guild-ban-add-event-fields -pub struct GuildBanAdd { - pub guild_id: String, - pub user: User, -} - -impl WebSocketEvent for GuildBanAdd {} - -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#guild-ban-remove -pub struct GuildBanRemove { - pub guild_id: String, - pub user: User, -} - -impl WebSocketEvent for GuildBanRemove {} \ No newline at end of file diff --git a/types/events/heartbeat.rs b/types/events/heartbeat.rs deleted file mode 100644 index cc73239..0000000 --- a/types/events/heartbeat.rs +++ /dev/null @@ -1,17 +0,0 @@ -use serde::{Deserialize, Serialize}; -use crate::events::WebSocketEvent; - -#[derive(Debug, Default, Deserialize, Serialize)] -pub struct GatewayHeartbeat { - pub op: u8, - pub d: Option, -} - -impl WebSocketEvent for GatewayHeartbeat {} - -#[derive(Debug, Default, Deserialize, Serialize)] -pub struct GatewayHeartbeatAck { - pub op: i32, -} - -impl WebSocketEvent for GatewayHeartbeatAck {} \ No newline at end of file diff --git a/types/events/hello.rs b/types/events/hello.rs deleted file mode 100644 index cb63dae..0000000 --- a/types/events/hello.rs +++ /dev/null @@ -1,17 +0,0 @@ -use serde::{Deserialize, Serialize}; -use crate::events::WebSocketEvent; - -#[derive(Debug, Default, Deserialize, Serialize)] -pub struct GatewayHello { - pub op: i32, - pub d: HelloData, -} - -impl WebSocketEvent for GatewayHello {} - -#[derive(Debug, Default, Deserialize, Serialize)] -pub struct HelloData { - pub heartbeat_interval: u128, -} - -impl WebSocketEvent for HelloData {} \ No newline at end of file diff --git a/types/events/identify.rs b/types/events/identify.rs deleted file mode 100644 index 7443631..0000000 --- a/types/events/identify.rs +++ /dev/null @@ -1,22 +0,0 @@ -use serde::{Deserialize, Serialize}; -use crate::events::{PresenceUpdate, WebSocketEvent}; - -#[derive(Debug, Deserialize, Serialize, Default)] -pub struct GatewayIdentifyPayload { - pub token: String, - pub properties: GatewayIdentifyConnectionProps, - pub compress: Option, - pub large_threshold: Option, //default: 50 - pub shard: Option>, - pub presence: Option, - pub intents: i32, -} - -impl WebSocketEvent for GatewayIdentifyPayload {} - -#[derive(Debug, Deserialize, Serialize, Default)] -pub struct GatewayIdentifyConnectionProps { - pub os: String, - pub browser: String, - pub device: String, -} \ No newline at end of file diff --git a/types/events/message.rs b/types/events/message.rs deleted file mode 100644 index edaaa4b..0000000 --- a/types/events/message.rs +++ /dev/null @@ -1,101 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::{ - entities::{Emoji, GuildMember, Message, User}, - utils::Snowflake, -}; - -use super::WebSocketEvent; - -#[derive(Debug, Deserialize, Serialize, Default)] -pub struct TypingStartEvent { - pub channel_id: String, - pub guild_id: Option, - pub user_id: String, - pub timestamp: i64, - pub member: Option, -} - -impl WebSocketEvent for TypingStartEvent {} - -#[derive(Debug, Serialize, Deserialize, Default)] -pub struct MessageCreate { - #[serde(flatten)] - message: Message, - guild_id: Option, - member: Option, - mentions: Vec<(User, GuildMember)>, // Not sure if this is correct: https://discord.com/developers/docs/topics/gateway-events#message-create -} - -impl WebSocketEvent for MessageCreate {} - -#[derive(Debug, Serialize, Deserialize, Default)] -pub struct MessageUpdate { - #[serde(flatten)] - message: Message, - guild_id: Option, - member: Option, - mentions: Vec<(User, GuildMember)>, // Not sure if this is correct: https://discord.com/developers/docs/topics/gateway-events#message-create -} - -impl WebSocketEvent for MessageUpdate {} - -#[derive(Debug, Serialize, Deserialize, Default)] -pub struct MessageDelete { - id: String, - channel_id: String, - guild_id: Option, -} - -impl WebSocketEvent for MessageDelete {} - -#[derive(Debug, Serialize, Deserialize, Default)] -pub struct MessageDeleteBulk { - ids: Vec, - channel_id: String, - guild_id: Option, -} - -impl WebSocketEvent for MessageDeleteBulk {} - -#[derive(Debug, Serialize, Deserialize, Default)] -pub struct MessageReactionAdd { - user_id: String, - channel_id: String, - message_id: String, - guild_id: Option, - member: Option, - emoji: Emoji, -} - -impl WebSocketEvent for MessageReactionAdd {} - -#[derive(Debug, Serialize, Deserialize, Default)] -pub struct MessageReactionRemove { - user_id: String, - channel_id: String, - message_id: String, - guild_id: Option, - emoji: Emoji, -} - -impl WebSocketEvent for MessageReactionRemove {} - -#[derive(Debug, Serialize, Deserialize, Default)] -pub struct MessageReactionRemoveAll { - channel_id: String, - message_id: String, - guild_id: Option, -} - -impl WebSocketEvent for MessageReactionRemoveAll {} - -#[derive(Debug, Serialize, Deserialize, Default)] -pub struct MessageReactionRemoveEmoji { - channel_id: String, - message_id: String, - guild_id: Option, - emoji: Emoji, -} - -impl WebSocketEvent for MessageReactionRemoveEmoji {} diff --git a/types/events/mod.rs b/types/events/mod.rs deleted file mode 100644 index 418cd31..0000000 --- a/types/events/mod.rs +++ /dev/null @@ -1,41 +0,0 @@ -use serde::{Deserialize, Serialize}; - -mod channel; -mod guild; -mod heartbeat; -mod hello; -mod identify; -mod message; -mod presence; -mod ready; -mod request_members; -mod resume; -mod thread; -mod user; -mod voice_status; - -pub use channel::*; -pub use guild::*; -pub use heartbeat::*; -pub use hello::*; -pub use identify::*; -pub use message::*; -pub use presence::*; -pub use ready::*; -pub use request_members::*; -pub use resume::*; -pub use thread::*; -pub use user::*; -pub use voice_status::*; - -pub trait WebSocketEvent {} - -#[derive(Debug, Default, Deserialize, Serialize)] -pub struct GatewayPayload { - pub op: u8, - pub d: Option, - pub s: Option, - pub t: Option, -} - -impl WebSocketEvent for GatewayPayload {} diff --git a/types/events/presence.rs b/types/events/presence.rs deleted file mode 100644 index c62e6ae..0000000 --- a/types/events/presence.rs +++ /dev/null @@ -1,24 +0,0 @@ -use serde::{Deserialize, Serialize}; -use crate::entities::User; -use crate::events::WebSocketEvent; -use crate::interfaces::Activity; - -#[derive(Debug, Deserialize, Serialize, Default, Clone)] -/// See https://discord.com/developers/docs/topics/gateway-events#presence-update-presence-update-event-fields -pub struct PresenceUpdate { - pub user: User, - pub guild_id: String, - pub status: String, - pub activities: Vec, - pub client_status: ClientStatusObject, -} - -#[derive(Debug, Deserialize, Serialize, Default, Clone)] -/// See https://discord.com/developers/docs/topics/gateway-events#client-status-object -pub struct ClientStatusObject { - pub desktop: Option, - pub mobile: Option, - pub web: Option, -} - -impl WebSocketEvent for PresenceUpdate {} \ No newline at end of file diff --git a/types/events/ready.rs b/types/events/ready.rs deleted file mode 100644 index 3d42f6e..0000000 --- a/types/events/ready.rs +++ /dev/null @@ -1,15 +0,0 @@ -use serde::{Deserialize, Serialize}; -use crate::entities::{UnavailableGuild, User}; -use crate::events::WebSocketEvent; - -#[derive(Debug, Deserialize, Serialize, Default)] -pub struct GatewayReady { - pub v: u8, - pub user: User, - pub guilds: Vec, - pub session_id: String, - pub resume_gateway_url: Option, - pub shard: Option<(u64, u64)>, -} - -impl WebSocketEvent for GatewayReady {} \ No newline at end of file diff --git a/types/events/request_members.rs b/types/events/request_members.rs deleted file mode 100644 index 192fe71..0000000 --- a/types/events/request_members.rs +++ /dev/null @@ -1,15 +0,0 @@ -use serde::{Deserialize, Serialize}; -use crate::events::WebSocketEvent; - -#[derive(Debug, Deserialize, Serialize, Default)] -/// See https://discord.com/developers/docs/topics/gateway-events#request-guild-members-request-guild-members-structure -pub struct GatewayRequestGuildMembers { - pub guild_id: String, - pub query: Option, - pub limit: u64, - pub presence: Option, - pub user_ids: Option, - pub nonce: Option, -} - -impl WebSocketEvent for GatewayRequestGuildMembers {} \ No newline at end of file diff --git a/types/events/resume.rs b/types/events/resume.rs deleted file mode 100644 index abdc5d6..0000000 --- a/types/events/resume.rs +++ /dev/null @@ -1,11 +0,0 @@ -use serde::{Deserialize, Serialize}; -use crate::events::WebSocketEvent; - -#[derive(Debug, Deserialize, Serialize, Default)] -pub struct GatewayResume { - pub token: String, - pub session_id: String, - pub seq: String, -} - -impl WebSocketEvent for GatewayResume {} \ No newline at end of file diff --git a/types/events/thread.rs b/types/events/thread.rs deleted file mode 100644 index 214ae8b..0000000 --- a/types/events/thread.rs +++ /dev/null @@ -1,82 +0,0 @@ -use serde::{Deserialize, Serialize}; -use crate::entities::{Channel, GuildMember, ThreadMember}; -use crate::events::WebSocketEvent; - -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#thread-create -/// Not directly serialized, as the inner payload is a channel object -pub struct ThreadCreate { - pub thread: Channel, -} - -impl WebSocketEvent for ThreadCreate {} - -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#thread-update -/// Not directly serialized, as the inner payload is a channel object -pub struct ThreadUpdate { - pub thread: Channel, -} - -impl WebSocketEvent for ThreadUpdate {} - -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#thread-delete -/// Not directly serialized, as the inner payload is a channel object -pub struct ThreadDelete { - pub thread: Channel, -} - -impl WebSocketEvent for ThreadDelete {} - -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#thread-list-sync -pub struct ThreadListSync { - pub guild_id: String, - pub channel_ids: Option>, - pub threads: Vec, - pub members: Vec, -} - -impl WebSocketEvent for ThreadListSync {} - -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#thread-member-update -/// The inner payload is a thread member object with an extra field. -/// The extra field is a bit painful, because we can't just serialize a thread member object -pub struct ThreadMemberUpdate { - pub id: Option, - pub user_id: Option, - pub join_timestamp: Option, - pub flags: Option, - pub member: Option, - pub guild_id: String, -} - -impl ThreadMemberUpdate { - /// Convert self to a thread member, losing the added guild_id field - pub fn to_thread_member(self) -> ThreadMember { - ThreadMember { - id: self.id, - user_id: self.user_id, - join_timestamp: self.join_timestamp.clone(), - flags: self.flags, - member: self.member, - } - } -} - -impl WebSocketEvent for ThreadMemberUpdate {} - -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#thread-members-update -pub struct ThreadMembersUpdate { - pub id: String, - pub guild_id: String, - /// Capped at 50 - pub member_count: u8, - pub added_members: Option>, - pub removed_members: Option>, -} - -impl WebSocketEvent for ThreadMembersUpdate {} \ No newline at end of file diff --git a/types/events/user.rs b/types/events/user.rs deleted file mode 100644 index 385bb43..0000000 --- a/types/events/user.rs +++ /dev/null @@ -1,12 +0,0 @@ -use serde::{Deserialize, Serialize}; -use crate::entities::User; -use crate::events::WebSocketEvent; - -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#user-update -/// Not directly serialized, as the inner payload is the user object -pub struct UserUpdate { - pub user: User, -} - -impl WebSocketEvent for UserUpdate {} \ No newline at end of file diff --git a/types/events/voice_status.rs b/types/events/voice_status.rs deleted file mode 100644 index 9e5b968..0000000 --- a/types/events/voice_status.rs +++ /dev/null @@ -1,13 +0,0 @@ -use serde::{Deserialize, Serialize}; -use crate::events::WebSocketEvent; - -#[derive(Debug, Deserialize, Serialize, Default)] -/// See https://discord.com/developers/docs/topics/gateway-events#update-voice-state-gateway-voice-state-update-structure -pub struct GatewayVoiceStateUpdate { - pub guild_id: String, - pub channel_id: Option, - pub self_mute: bool, - pub self_deaf: bool, -} - -impl WebSocketEvent for GatewayVoiceStateUpdate {} \ No newline at end of file diff --git a/types/interfaces/activity.rs b/types/interfaces/activity.rs deleted file mode 100644 index fd3e4be..0000000 --- a/types/interfaces/activity.rs +++ /dev/null @@ -1,57 +0,0 @@ -use serde::{Deserialize, Serialize}; -use crate::entities::Emoji; - -#[derive(Debug, Deserialize, Serialize, Clone)] -pub struct Activity { - name: String, - #[serde(rename = "type")] - activity_type: i32, - url: Option, - created_at: i64, - timestamps: Option, - application_id: Option, - details: Option, - state: Option, - emoji: Option, - party: Option, - assets: Option, - secrets: Option, - instance: Option, - flags: Option, - buttons: Option>, -} - - -#[derive(Debug, Deserialize, Serialize, Clone)] -struct ActivityTimestamps { - start: Option, - end: Option, -} - -#[derive(Debug, Deserialize, Serialize, Clone)] -struct ActivityParty { - id: Option, - size: Option>, -} - -#[derive(Debug, Deserialize, Serialize, Clone)] -struct ActivityAssets { - large_image: Option, - large_text: Option, - small_image: Option, - small_text: Option, -} - -#[derive(Debug, Deserialize, Serialize, Clone)] -struct ActivitySecrets { - join: Option, - spectate: Option, - #[serde(rename = "match")] - match_string: Option, -} - -#[derive(Debug, Deserialize, Serialize, Clone)] -struct ActivityButton { - label: String, - url: String, -} \ No newline at end of file diff --git a/types/interfaces/connected_account.rs b/types/interfaces/connected_account.rs deleted file mode 100644 index e69de29..0000000 diff --git a/types/interfaces/guild_welcome_screen.rs b/types/interfaces/guild_welcome_screen.rs deleted file mode 100644 index af645d3..0000000 --- a/types/interfaces/guild_welcome_screen.rs +++ /dev/null @@ -1,17 +0,0 @@ -use serde::{Deserialize, Serialize}; -use crate::utils::Snowflake; - -#[derive(Serialize, Deserialize, Debug, Default, Clone)] -pub struct WelcomeScreenObject { - pub enabled: bool, - pub description: Option, - pub welcome_channels: Vec, -} - -#[derive(Serialize, Deserialize, Debug, Default, Clone)] -pub struct WelcomeScreenChannel { - pub channel_id: Snowflake, - pub description: String, - pub emoji_id: Option, - pub emoji_name: Option, -} \ No newline at end of file diff --git a/types/interfaces/interaction.rs b/types/interfaces/interaction.rs deleted file mode 100644 index 76b18e4..0000000 --- a/types/interfaces/interaction.rs +++ /dev/null @@ -1,39 +0,0 @@ -use serde::{Deserialize, Serialize}; -use serde_json::Value; -use crate::entities::{AllowedMention, Embed}; -use crate::utils::Snowflake; - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -pub struct Interaction { - pub id: Snowflake, - pub r#type: InteractionType, - pub data: Value, - pub guild_id: Snowflake, - pub channel_id: Snowflake, - pub member_id: Snowflake, - pub token: String, - pub version: i32, -} - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -pub enum InteractionType { - SelfCommand = 0, - Ping = 1, - ApplicationCommand = 2 -} - -pub enum InteractionResponseType { - SelfCommandResponse = 0, - Pong = 1, - Acknowledge = 2, - ChannelMessage = 3, - ChannelMessageWithSource = 4, - AcknowledgeWithSource = 5, -} - -pub struct InteractionApplicationCommandCallbackData { - pub tts: bool, - pub content: String, - pub embeds: Vec, - pub allowed_mentions: AllowedMention -} diff --git a/types/interfaces/mod.rs b/types/interfaces/mod.rs deleted file mode 100644 index 6e0a7df..0000000 --- a/types/interfaces/mod.rs +++ /dev/null @@ -1,11 +0,0 @@ -mod activity; -mod connected_account; -mod guild_welcome_screen; -mod interaction; -mod status; - -pub use activity::*; -pub use connected_account::*; -pub use guild_welcome_screen::*; -pub use interaction::*; -pub use status::*; \ No newline at end of file diff --git a/types/interfaces/status.rs b/types/interfaces/status.rs deleted file mode 100644 index 105dd87..0000000 --- a/types/interfaces/status.rs +++ /dev/null @@ -1,9 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Deserialize, Serialize, Default, Clone)] -/// See https://discord.com/developers/docs/topics/gateway-events#client-status-object -pub struct ClientStatusObject { - pub desktop: Option, - pub mobile: Option, - pub web: Option, -} \ No newline at end of file diff --git a/types/lib.rs b/types/lib.rs deleted file mode 100644 index a3b0671..0000000 --- a/types/lib.rs +++ /dev/null @@ -1,7 +0,0 @@ -pub mod config; // Maybe feature lock this for backend/web usage only? web would only need it in the case of the admin panel -pub mod entities; -pub mod errors; -pub mod events; -pub mod utils; -pub mod interfaces; -pub mod schema; diff --git a/types/schema/apierror.rs b/types/schema/apierror.rs deleted file mode 100644 index 95e72a5..0000000 --- a/types/schema/apierror.rs +++ /dev/null @@ -1,72 +0,0 @@ -#[cfg(feature = "poem")] -use poem::{http::StatusCode, IntoResponse, Response}; -use serde_json::{json, Value}; - -#[derive(Debug, thiserror::Error)] -pub enum APIError { - #[error(transparent)] - Auth(#[from] AuthError), -} - -impl APIError { - pub fn error_payload(&self) -> Value { - match self { - APIError::Auth(auth_err) => auth_err.error_payload(), - } - } -} - -#[derive(Debug, thiserror::Error)] -pub enum AuthError { - #[error("INVALID_LOGIN")] - InvalidLogin, - #[error("INVALID_CAPTCHA")] - InvalidCaptcha, -} - -impl AuthError { - pub fn error_code(&self) -> &str { - match self { - AuthError::InvalidLogin => "INVALID_LOGIN", - AuthError::InvalidCaptcha => "INVALID_CATPCA", - } - } - - pub fn error_payload(&self) -> Value { - match self { - AuthError::InvalidLogin => json!({ - "login": { - "message": "auth:login.INVALID_LOGIN", - "code": self.error_code() - } - }), - AuthError::InvalidCaptcha => json!([json!({ - "captcha_key": "TODO", - "captcha_sitekey": "TODO", - "captcha_service": "TODO" - })]), - } - } -} - -#[cfg(feature = "poem")] -impl poem::error::ResponseError for APIError { - fn status(&self) -> StatusCode { - match self { - APIError::Auth(auth_err) => match auth_err { - AuthError::InvalidLogin => StatusCode::UNAUTHORIZED, - AuthError::InvalidCaptcha => StatusCode::BAD_REQUEST, - }, - } - } - - fn as_response(&self) -> Response - where - Self: std::error::Error + Send + Sync + 'static, - { - Response::builder() - .status(self.status()) - .body(self.error_payload().to_string()) - .into_response() - } -} diff --git a/types/schema/auth.rs b/types/schema/auth.rs deleted file mode 100644 index 073d8d4..0000000 --- a/types/schema/auth.rs +++ /dev/null @@ -1,240 +0,0 @@ -use crate::errors::FieldFormatError; -use regex::Regex; -use serde::{Deserialize, Serialize}; - -/** -A struct that represents a well-formed email address. - */ -#[derive(Clone, PartialEq, Eq, Debug)] -pub struct AuthEmail { - pub email: String, -} - -impl AuthEmail { - /** - Returns a new [`Result`]. - ## Arguments - The email address you want to validate. - ## Errors - You will receive a [`FieldFormatError`], if: - - The email address is not in a valid format. - - */ - pub fn new(email: String) -> Result { - let regex = Regex::new(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$").unwrap(); - if !regex.is_match(email.as_str()) { - return Err(FieldFormatError::EmailError); - } - Ok(AuthEmail { email }) - } -} - -/** -A struct that represents a well-formed username. -## Arguments -Please use new() to create a new instance of this struct. -## Errors -You will receive a [`FieldFormatError`], if: -- The username is not between 2 and 32 characters. - */ -#[derive(Clone, PartialEq, Eq, Debug)] -pub struct AuthUsername { - pub username: String, -} - -impl AuthUsername { - /** - Returns a new [`Result`]. - ## Arguments - The username you want to validate. - ## Errors - You will receive a [`FieldFormatError`], if: - - The username is not between 2 and 32 characters. - */ - pub fn new(username: String) -> Result { - if username.len() < 2 || username.len() > 32 { - Err(FieldFormatError::UsernameError) - } else { - Ok(AuthUsername { username }) - } - } -} - -/** -A struct that represents a well-formed password. -## Arguments -Please use new() to create a new instance of this struct. -## Errors -You will receive a [`FieldFormatError`], if: -- The password is not between 1 and 72 characters. - */ -#[derive(Clone, PartialEq, Eq, Debug)] -pub struct AuthPassword { - pub password: String, -} - -impl AuthPassword { - /** - Returns a new [`Result`]. - ## Arguments - The password you want to validate. - ## Errors - You will receive a [`FieldFormatError`], if: - - The password is not between 1 and 72 characters. - */ - pub fn new(password: String) -> Result { - if password.is_empty() || password.len() > 72 { - Err(FieldFormatError::PasswordError) - } else { - Ok(AuthPassword { password }) - } - } -} - -/** -A struct that represents a well-formed register request. -## Arguments -Please use new() to create a new instance of this struct. -## Errors -You will receive a [`FieldFormatError`], if: -- The username is not between 2 and 32 characters. -- The password is not between 1 and 72 characters. - */ - -#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)] -#[serde(rename_all = "snake_case")] -pub struct RegisterSchema { - username: String, - password: Option, - consent: bool, - email: Option, - fingerprint: Option, - invite: Option, - date_of_birth: Option, - gift_code_sku_id: Option, - captcha_key: Option, - promotional_email_opt_in: Option, -} - -impl RegisterSchema { - /** - Returns a new [`Result`]. - ## Arguments - All but "String::username" and "bool::consent" are optional. - - ## Errors - You will receive a [`FieldFormatError`], if: - - The username is less than 2 or more than 32 characters in length - - You supply a `password` which is less than 1 or more than 72 characters in length. - - These constraints have been defined [in the Spacebar-API](https://docs.spacebar.chat/routes/) - */ - pub fn new( - username: String, - password: Option, - consent: bool, - email: Option, - fingerprint: Option, - invite: Option, - date_of_birth: Option, - gift_code_sku_id: Option, - captcha_key: Option, - promotional_email_opt_in: Option, - ) -> Result { - let username = AuthUsername::new(username)?.username; - - let email = if let Some(email) = email { - Some(AuthEmail::new(email)?.email) - } else { - None - }; - - let password = if let Some(password) = password { - Some(AuthPassword::new(password)?.password) - } else { - None - }; - - if !consent { - return Err(FieldFormatError::ConsentError); - } - - Ok(RegisterSchema { - username, - password, - consent, - email, - fingerprint, - invite, - date_of_birth, - gift_code_sku_id, - captcha_key, - promotional_email_opt_in, - }) - } -} - -/** -A struct that represents a well-formed login request. -## Arguments -Please use new() to create a new instance of this struct. -## Errors -You will receive a [`FieldFormatError`], if: -- The username is not between 2 and 32 characters. -- The password is not between 1 and 72 characters. - */ -#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)] -#[serde(rename_all = "snake_case")] -pub struct LoginSchema { - pub login: String, - pub password: String, - pub undelete: Option, - pub captcha_key: Option, - pub login_source: Option, - pub gift_code_sku_id: Option, -} - -impl LoginSchema { - /** - Returns a new [`Result`]. - ## Arguments - login: The username you want to login with. - password: The password you want to login with. - undelete: Honestly no idea what this is for. - captcha_key: The captcha key you want to login with. - login_source: The login source. - gift_code_sku_id: The gift code sku id. - ## Errors - You will receive a [`FieldFormatError`], if: - - The username is less than 2 or more than 32 characters in length - */ - pub fn new( - login: String, - password: String, - undelete: Option, - captcha_key: Option, - login_source: Option, - gift_code_sku_id: Option, - ) -> Result { - let login = AuthUsername::new(login)?.username; - let password = AuthPassword::new(password)?.password; - - Ok(LoginSchema { - login, - password, - undelete, - captcha_key, - login_source, - gift_code_sku_id, - }) - } -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(rename_all = "snake_case")] -pub struct TotpSchema { - code: String, - ticket: String, - gift_code_sku_id: Option, - login_source: Option, -} diff --git a/types/schema/channel.rs b/types/schema/channel.rs deleted file mode 100644 index f6ee53c..0000000 --- a/types/schema/channel.rs +++ /dev/null @@ -1,27 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::entities::PermissionOverwrite; - -#[derive(Debug, Deserialize, Serialize)] -#[serde(rename_all = "snake_case")] -pub struct ChannelCreateSchema { - pub name: String, - #[serde(rename = "type")] - pub channel_type: Option, - pub topic: Option, - pub icon: Option, - pub bitrate: Option, - pub user_limit: Option, - pub rate_limit_per_user: Option, - pub position: Option, - pub permission_overwrites: Option>, - pub parent_id: Option, - pub id: Option, - pub nsfw: Option, - pub rtc_region: Option, - pub default_auto_archive_duration: Option, - pub default_reaction_emoji: Option, - pub flags: Option, - pub default_thread_rate_limit_per_user: Option, - pub video_quality_mode: Option, -} diff --git a/types/schema/guild.rs b/types/schema/guild.rs deleted file mode 100644 index 92bb635..0000000 --- a/types/schema/guild.rs +++ /dev/null @@ -1,14 +0,0 @@ -use serde::{Deserialize, Serialize}; -use crate::entities::Channel; - -#[derive(Debug, Deserialize, Serialize)] -#[serde(rename_all = "snake_case")] -pub struct GuildCreateSchema { - pub name: Option, - pub region: Option, - pub icon: Option, - pub channels: Option>, - pub guild_template_code: Option, - pub system_channel_id: Option, - pub rules_channel_id: Option, -} \ No newline at end of file diff --git a/types/schema/message.rs b/types/schema/message.rs deleted file mode 100644 index a37f581..0000000 --- a/types/schema/message.rs +++ /dev/null @@ -1,47 +0,0 @@ -use serde::{Deserialize, Serialize}; -use crate::entities::{AllowedMention, Component, Embed, MessageReference, PartialDiscordFileAttachment}; - -#[derive(Debug, Deserialize, Serialize)] -#[serde(rename_all = "snake_case")] -pub struct MessageSendSchema { - #[serde(rename = "type")] - message_type: Option, - content: Option, - nonce: Option, - tts: Option, - embeds: Option>, - allowed_mentions: Option, - message_reference: Option, - components: Option>, - sticker_ids: Option>, - pub attachments: Option>, -} - -// make a new() method for MessageSendSchema -impl MessageSendSchema { - pub fn new( - message_type: Option, - content: Option, - nonce: Option, - tts: Option, - embeds: Option>, - allowed_mentions: Option, - message_reference: Option, - components: Option>, - sticker_ids: Option>, - attachments: Option>, - ) -> MessageSendSchema { - MessageSendSchema { - message_type, - content, - nonce, - tts, - embeds, - allowed_mentions, - message_reference, - components, - sticker_ids, - attachments, - } - } -} \ No newline at end of file diff --git a/types/schema/mod.rs b/types/schema/mod.rs deleted file mode 100644 index 6fe3e37..0000000 --- a/types/schema/mod.rs +++ /dev/null @@ -1,103 +0,0 @@ -mod apierror; -mod auth; -mod channel; -mod guild; -mod message; -mod user; - -pub use apierror::*; -pub use auth::*; -pub use channel::*; -pub use guild::*; -pub use message::*; -pub use user::*; - -#[cfg(test)] -mod schemas_tests { - use super::*; - use crate::errors::FieldFormatError; - - #[test] - fn password_too_short() { - assert_eq!( - AuthPassword::new("".to_string()), - Err(FieldFormatError::PasswordError) - ); - } - - #[test] - fn password_too_long() { - let mut long_pw = String::new(); - for _ in 0..73 { - long_pw += "a"; - } - assert_eq!( - AuthPassword::new(long_pw), - Err(FieldFormatError::PasswordError) - ); - } - - #[test] - fn username_too_short() { - assert_eq!( - AuthUsername::new("T".to_string()), - Err(FieldFormatError::UsernameError) - ); - } - - #[test] - fn username_too_long() { - let mut long_un = String::new(); - for _ in 0..33 { - long_un += "a"; - } - assert_eq!( - AuthUsername::new(long_un), - Err(FieldFormatError::UsernameError) - ); - } - - #[test] - fn consent_false() { - assert_eq!( - RegisterSchema::new( - "Test".to_string(), - None, - false, - None, - None, - None, - None, - None, - None, - None, - ), - Err(FieldFormatError::ConsentError) - ); - } - - #[test] - fn invalid_email() { - assert_eq!( - AuthEmail::new("p@p.p".to_string()), - Err(FieldFormatError::EmailError) - ) - } - - #[test] - fn valid_email() { - let reg = RegisterSchema::new( - "Testy".to_string(), - None, - true, - Some("me@mail.de".to_string()), - None, - None, - None, - None, - None, - None, - ); - assert_ne!(reg, Err(FieldFormatError::EmailError)); - } -} diff --git a/types/schema/user.rs b/types/schema/user.rs deleted file mode 100644 index 00f4962..0000000 --- a/types/schema/user.rs +++ /dev/null @@ -1,16 +0,0 @@ -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Deserialize, Serialize)] -#[serde(rename_all = "snake_case")] -pub struct UserModifySchema { - pub username: Option, - pub avatar: Option, - pub bio: Option, - pub accent_color: Option, - pub banner: Option, - pub current_password: Option, - pub new_password: Option, - pub code: Option, - pub email: Option, - pub discriminator: Option, -} \ No newline at end of file diff --git a/types/utils/jwt.rs b/types/utils/jwt.rs deleted file mode 100644 index 0a38dd4..0000000 --- a/types/utils/jwt.rs +++ /dev/null @@ -1,44 +0,0 @@ -use jsonwebtoken::{encode, EncodingKey, Header}; -use serde::{Deserialize, Serialize}; - -use crate::{utils::Snowflake}; - -pub fn generate_token(id: &Snowflake, email: String, jwt_key: &str) -> String { - let claims = Claims::new(&email, id); - - build_token(&claims, jwt_key).unwrap() -} - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct Claims { - pub exp: i64, - pub iat: i64, - pub email: String, - pub id: String, -} - -impl Claims { - pub fn new(user: &str, id: &Snowflake) -> Self { - let unix = chrono::Utc::now().timestamp(); - Self { - exp: unix + (60 * 60 * 24), - id: id.to_string(), - iat: unix, - email: user.to_string(), - } - } -} - -pub fn build_token(claims: &Claims, jwt_key: &str) -> Result { - encode( - &Header::default(), - claims, - &EncodingKey::from_secret(jwt_key.as_bytes()), - ) -} - -/*pub fn decode_token(token: &str) -> Result, Error> { - let mut validation = Validation::new(Algorithm::HS256); - validation.sub = Some("quartzauth".to_string()); - decode(token, &DecodingKey::from_secret(JWT_SECRET), &validation) -}*/ diff --git a/types/utils/mod.rs b/types/utils/mod.rs deleted file mode 100644 index ec2fd4a..0000000 --- a/types/utils/mod.rs +++ /dev/null @@ -1,8 +0,0 @@ -pub mod jwt; -mod regexes; -mod rights; -mod snowflake; - -pub use regexes::*; -pub use rights::Rights; -pub use snowflake::{DeconstructedSnowflake, Snowflake}; diff --git a/types/utils/regexes.rs b/types/utils/regexes.rs deleted file mode 100644 index 0f160eb..0000000 --- a/types/utils/regexes.rs +++ /dev/null @@ -1,12 +0,0 @@ -use lazy_static::lazy_static; -use regex::Regex; - -lazy_static! { - static ref DOUBLE_WHITE_SPACE_RE: Regex = Regex::new(r"\s\s+").unwrap(); - static ref SPECIAL_CHAR: Regex = Regex::new(r"@#`:\r\n\t\f\v\p{C}").unwrap(); - static ref CHANNEL_MENTION: Regex = Regex::new(r"<#(\d+)>").unwrap(); - static ref USER_MENTION: Regex = Regex::new(r"<@!?(\d+)>").unwrap(); - static ref ROLE_MENTION: Regex = Regex::new(r"<@&(\d+)>").unwrap(); - static ref EVERYONE_MENTION: Regex = Regex::new(r"@everyone").unwrap(); - static ref HERE_MENTION: Regex = Regex::new(r"@here").unwrap(); -} diff --git a/types/utils/rights.rs b/types/utils/rights.rs deleted file mode 100644 index 0198af6..0000000 --- a/types/utils/rights.rs +++ /dev/null @@ -1,127 +0,0 @@ -use bitflags::bitflags; - -bitflags! { - pub struct Rights: u64 { - const OPERATOR = 1 << 0; - const MANAGE_APPLICATIONS = 1 << 1; - const MANAGE_GUILDS = 1 << 2; - const MANAGE_MESSAGES = 1 << 3; - const MANAGE_RATE_LIMITS = 1 << 4; - const MANAGE_ROUTING = 1 << 5; - const MANAGE_TICKETS = 1 << 6; - const MANAGE_USERS = 1 << 7; - const ADD_MEMBERS = 1 << 8; - const BYPASS_RATE_LIMITS = 1 << 9; - const CREATE_APPLICATIONS = 1 << 10; - const CREATE_CHANNELS = 1 << 11; - const CREATE_DMS = 1 << 12; - const CREATE_DM_GROUPS = 1 << 13; - const CREATE_GUILDS = 1 << 14; - const CREATE_INVITES = 1 << 15; - const CREATE_ROLES = 1 << 16; - const CREATE_TEMPLATES = 1 << 17; - const CREATE_WEBHOOKS = 1 << 18; - const JOIN_GUILDS = 1 << 19; - const PIN_MESSAGES = 1 << 20; - const SELF_ADD_REACTIONS = 1 << 21; - const SELF_DELETE_MESSAGES = 1 << 22; - const SELF_EDIT_MESSAGES = 1 << 23; - const SELF_EDIT_NAME = 1 << 24; - const SEND_MESSAGES = 1 << 25; - const USE_ACTIVITIES = 1 << 26; - const USE_VIDEO = 1 << 27; - const USE_VOICE = 1 << 28; - const INVITE_USERS = 1 << 29; - const SELF_DELETE_DISABLE = 1 << 30; - const DEBTABLE = 1 << 31; - const CREDITABLE = 1 << 32; - const KICK_BAN_MEMBERS = 1 << 33; - const SELF_LEAVE_GROUPS = 1 << 34; - const PRESENCE = 1 << 35; - const SELF_ADD_DISCOVERABLE = 1 << 36; - const MANAGE_GUILD_DIRECTORY = 1 << 37; - const POGGERS = 1 << 38; - const USE_ACHIEVEMENTS = 1 << 39; - const INITIATE_INTERACTIONS = 1 << 40; - const RESPOND_TO_INTERACTIONS = 1 << 41; - const SEND_BACKDATED_EVENTS = 1 << 42; - const USE_MASS_INVITES = 1 << 43; - const ACCEPT_INVITES = 1 << 44; - const SELF_EDIT_FLAGS = 1 << 45; - const EDIT_FLAGS = 1 << 46; - const MANAGE_GROUPS = 1 << 47; - const VIEW_SERVER_STATS = 1 << 48; - const RESEND_VERIFICATION_EMAIL = 1 << 49; - } -} - -impl Rights { - pub fn any(&self, permission: Rights, check_operator: bool) -> bool { - (check_operator && self.contains(Rights::OPERATOR)) || self.contains(permission) - } - - pub fn has(&self, permission: Rights, check_operator: bool) -> bool { - (check_operator && self.contains(Rights::OPERATOR)) || self.contains(permission) - } - - pub fn has_throw(&self, permission: Rights) -> Result { - if self.has(permission, true) { - Ok(true) - } else { - Err("You are missing the following rights") - } - } -} - -fn all_rights() -> Rights { - Rights::OPERATOR - | Rights::MANAGE_APPLICATIONS - | Rights::MANAGE_GUILDS - | Rights::MANAGE_MESSAGES - | Rights::MANAGE_RATE_LIMITS - | Rights::MANAGE_ROUTING - | Rights::MANAGE_TICKETS - | Rights::MANAGE_USERS - | Rights::ADD_MEMBERS - | Rights::BYPASS_RATE_LIMITS - | Rights::CREATE_APPLICATIONS - | Rights::CREATE_CHANNELS - | Rights::CREATE_DMS - | Rights::CREATE_DM_GROUPS - | Rights::CREATE_GUILDS - | Rights::CREATE_INVITES - | Rights::CREATE_ROLES - | Rights::CREATE_TEMPLATES - | Rights::CREATE_WEBHOOKS - | Rights::JOIN_GUILDS - | Rights::PIN_MESSAGES - | Rights::SELF_ADD_REACTIONS - | Rights::SELF_DELETE_MESSAGES - | Rights::SELF_EDIT_MESSAGES - | Rights::SELF_EDIT_NAME - | Rights::SEND_MESSAGES - | Rights::USE_ACTIVITIES - | Rights::USE_VIDEO - | Rights::USE_VOICE - | Rights::INVITE_USERS - | Rights::SELF_DELETE_DISABLE - | Rights::DEBTABLE - | Rights::CREDITABLE - | Rights::KICK_BAN_MEMBERS - | Rights::SELF_LEAVE_GROUPS - | Rights::PRESENCE - | Rights::SELF_ADD_DISCOVERABLE - | Rights::MANAGE_GUILD_DIRECTORY - | Rights::POGGERS - | Rights::USE_ACHIEVEMENTS - | Rights::INITIATE_INTERACTIONS - | Rights::RESPOND_TO_INTERACTIONS - | Rights::SEND_BACKDATED_EVENTS - | Rights::USE_MASS_INVITES - | Rights::ACCEPT_INVITES - | Rights::SELF_EDIT_FLAGS - | Rights::EDIT_FLAGS - | Rights::MANAGE_GROUPS - | Rights::VIEW_SERVER_STATS - | Rights::RESEND_VERIFICATION_EMAIL -} diff --git a/types/utils/snowflake.rs b/types/utils/snowflake.rs deleted file mode 100644 index 7c756fa..0000000 --- a/types/utils/snowflake.rs +++ /dev/null @@ -1,160 +0,0 @@ -use std::fmt::Display; - -use atomic::Atomic; -use bigdecimal::{Num, ToPrimitive, Zero}; -use num_bigint::{BigInt, ToBigInt}; -use serde::{Deserialize, Serialize}; -#[cfg(feature = "sqlx")] -use sqlx::Type; - -const EPOCH: i64 = 1420070400000; -static WORKER_ID: u128 = 0; -static PROCESS_ID: u128 = 1; -lazy_static::lazy_static! { - static ref INCREMENT: Atomic = Atomic::default(); -} -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[cfg_attr(feature = "sqlx", derive(Type))] -#[cfg_attr(feature = "sqlx", sqlx(transparent))] -pub struct Snowflake(String); - -impl Default for Snowflake { - fn default() -> Self { - Self::generate() - } -} - -impl Display for Snowflake { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.0) - } -} - -impl Snowflake { - pub fn to_binary(&self) -> String { - let self_len = self.0.len(); - let high = self.0[..self_len - 10].parse::().unwrap_or(0); - let low = self.0[self_len - 10..].parse::().unwrap(); - let mut low = low; - let mut high = high; - let mut bin = Vec::with_capacity(64); - - while low > 0 || high > 0 { - bin.push((low & 1) as u8); - low >>= 1; - - if high > 0 { - low += 5_000_000_000 * (high % 2); - high >>= 1; - } - } - - bin.iter() - .rev() - .map(|b| char::from_digit(*b as u32, 10).unwrap()) - .collect() - } - - pub fn from_binary(num: &str) -> String { - let mut num = BigInt::from_str_radix(num, 2).unwrap(); - let mut dec = Vec::with_capacity(18); - - let ten = 10.to_bigint().unwrap(); - let _two = 2.to_bigint().unwrap(); - let _thirty_two = 32.to_bigint().unwrap(); - - while num.bits() > 50 { - let high: BigInt = &num >> 32; - let low: BigInt = (high.clone() % &ten) << 32 | &num & BigInt::from((1u64 << 32) - 1); - - let next: BigInt = low.clone() % &ten; - dec.push(next.to_u8().unwrap()); - num = (high / &ten) << 32 | (low / &ten); - } - - while !num.is_zero() { - dec.push((num.clone() % &ten).to_u8().unwrap()); - num /= &ten; - } - - dec.iter() - .rev() - .map(|d| char::from_digit(*d as u32, 10).unwrap()) - .collect() - } - - pub fn generate_worker_process() -> u128 { - let time = (chrono::Utc::now().naive_utc().timestamp_millis() - EPOCH) << 22; - let worker = WORKER_ID << 17; - let process = PROCESS_ID << 12; - let increment = INCREMENT.load(atomic::Ordering::Relaxed); - - INCREMENT.store(increment + 1, atomic::Ordering::Relaxed); - - time as u128 | worker | process | increment - } - - pub fn generate() -> Self { - Self(Self::generate_worker_process().to_string()) - } - - pub fn deconstruct(&self) -> DeconstructedSnowflake { - let binary = format!("{:0>64}", self.to_binary()); - - let ts = i64::from_str_radix(&binary[0..42], 2).unwrap() + EPOCH; - let wid = u64::from_str_radix(&binary[42..47], 2).unwrap(); - let pid = u64::from_str_radix(&binary[47..52], 2).unwrap(); - let increment = BigInt::from_str_radix(&binary[52..64], 2).unwrap(); - - DeconstructedSnowflake { - timestamp: ts, - worker_id: wid, - process_id: pid, - increment, - binary, - } - } -} - -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct DeconstructedSnowflake { - pub timestamp: i64, - pub worker_id: u64, - pub process_id: u64, - pub increment: BigInt, - pub binary: String, -} - -#[cfg(test)] -mod test { - use super::Snowflake; - - #[test] - fn test_new_snowflake() { - let snow = Snowflake::generate(); - println!("{snow}"); - } - - #[test] - fn snowflake_to_binary() { - let snowflake = super::Snowflake("1104339392517902336".to_string()); - - let bin = snowflake.to_binary(); - println!("{bin}"); - } - - #[test] - fn binary_to_snowflake() { - let snowflake = super::Snowflake::from_binary( - "111101010011011001101101001110010010100000000001000000000000", - ); - println!("{snowflake}"); - } - - #[test] - fn test_deconstruct() { - let new = super::Snowflake::generate(); - - println!("{:?}", new.deconstruct()); - } -} From 73b1cd31e246293fa3f6c51314a78a57368ddbd4 Mon Sep 17 00:00:00 2001 From: Flori <39242991+bitfl0wer@users.noreply.github.com> Date: Thu, 1 Jun 2023 19:16:25 +0200 Subject: [PATCH 42/42] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index bc696a1..83cebca 100644 --- a/README.md +++ b/README.md @@ -45,7 +45,7 @@ - [x] [Channel management (name, description, icon, etc.)](https://github.com/polyphony-chat/chorus/issues/48) - [ ] Deleting messages - [ ] Message threads -- [ ] Reactions +- [ ] [Reactions](https://github.com/polyphony-chat/chorus/issues/85) - [ ] Message Search - [ ] Message history