Invites (#502)

- Modify Invite entity to work with symfonia
- Adds custom deserialization to InviteFlags

src/types/entities/channel.rs

@@ -177,7 +177,7 @@ pub struct ThreadMember {
     pub member: Option<Shared<GuildMember>>,
 }
 
-#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq, PartialOrd)]
 /// Specifies the emoji to use as the default way to react to a [ChannelType::GuildForum] or [ChannelType::GuildMedia] channel post.
 ///
 /// # Reference

src/types/entities/invite.rs

@@ -5,7 +5,7 @@
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 
-use crate::types::{Snowflake, WelcomeScreenObject, Shared};
+use crate::types::{Snowflake, WelcomeScreenObject, Shared, InviteFlags, InviteType, InviteTargetType};
 
 use super::guild::GuildScheduledEvent;
 use super::{Application, Channel, GuildMember, NSFWLevel, User};
@@ -13,25 +13,35 @@ use super::{Application, Channel, GuildMember, NSFWLevel, User};
 /// Represents a code that when used, adds a user to a guild or group DM channel, or creates a relationship between two users.
 /// See <https://discord-userdoccers.vercel.app/resources/invite#invite-object>
 #[derive(Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
 pub struct Invite {
     pub approximate_member_count: Option<i32>,
     pub approximate_presence_count: Option<i32>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub channel: Option<Channel>,
     pub code: String,
     pub created_at: Option<DateTime<Utc>>,
     pub expires_at: Option<DateTime<Utc>>,
-    pub flags: Option<i32>,
+    pub flags: Option<InviteFlags>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub guild: Option<InviteGuild>,
     pub guild_id: Option<Snowflake>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub guild_scheduled_event: Option<Shared<GuildScheduledEvent>>,
     #[serde(rename = "type")]
-    pub invite_type: Option<i32>,
+    #[cfg_attr(feature = "sqlx", sqlx(rename = "type"))]
+    pub invite_type: Option<InviteType>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub inviter: Option<User>,
-    pub max_age: Option<i32>,
+    pub max_age: Option<u32>,
-    pub max_uses: Option<i32>,
+    pub max_uses: Option<u8>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub stage_instance: Option<InviteStageInstance>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub target_application: Option<Application>,
-    pub target_type: Option<i32>,
+    #[cfg_attr(feature = "sqlx", sqlx(rename = "target_user_type"))]
+    pub target_type: Option<InviteTargetType>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub target_user: Option<User>,
     pub temporary: Option<bool>,
     pub uses: Option<i32>,

src/types/errors.rs

@@ -21,6 +21,9 @@ pub enum Error {
 
     #[error(transparent)]
     Guild(#[from] GuildError),
+    
+    #[error("Invalid flags value: {0}")]
+    InvalidFlags(u64)
 }
 
 #[derive(Debug, PartialEq, Eq, thiserror::Error)]

src/types/schema/channel.rs

@@ -3,10 +3,10 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 use bitflags::bitflags;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde::de::Visitor;
 
-use crate::types::ChannelType;
+use crate::types::{ChannelType, DefaultReaction, Error, entities::PermissionOverwrite, Snowflake};
-use crate::types::{entities::PermissionOverwrite, Snowflake};
 
 #[derive(Debug, Deserialize, Serialize, Default, PartialEq, PartialOrd)]
 #[serde(rename_all = "snake_case")]
@@ -48,7 +48,7 @@ pub struct ChannelModifySchema {
     pub nsfw: Option<bool>,
     pub rtc_region: Option<String>,
     pub default_auto_archive_duration: Option<i32>,
-    pub default_reaction_emoji: Option<String>,
+    pub default_reaction_emoji: Option<DefaultReaction>,
     pub flags: Option<i32>,
     pub default_thread_rate_limit_per_user: Option<i32>,
     pub video_quality_mode: Option<i32>,
@@ -109,7 +109,7 @@ pub struct CreateChannelInviteSchema {
     pub temporary: Option<bool>,
     pub unique: Option<bool>,
     pub validate: Option<String>,
-    pub target_type: Option<InviteType>,
+    pub target_type: Option<InviteTargetType>,
     pub target_user_id: Option<Snowflake>,
     pub target_application_id: Option<Snowflake>,
 }
@@ -131,15 +131,79 @@ impl Default for CreateChannelInviteSchema {
 }
 
 bitflags! {
-    #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord)]
+    #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
     pub struct InviteFlags: u64 {
         const GUEST = 1 << 0;
+        const VIEWED = 1 << 1;
+    }
+}
+
+impl Serialize for InviteFlags {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.bits().to_string().serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for InviteFlags {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
+        struct FlagsVisitor;
+
+        impl<'de> Visitor<'de> for FlagsVisitor
+        {
+            type Value = InviteFlags;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("a raw u64 value of flags")
+            }
+
+            fn visit_u64<E: serde::de::Error>(self, v: u64) -> Result<Self::Value, E> {
+                InviteFlags::from_bits(v).ok_or(serde::de::Error::custom(Error::InvalidFlags(v)))
+            }
+        }
+
+        deserializer.deserialize_u64(FlagsVisitor)
+    }
+}
+
+#[cfg(feature = "sqlx")]
+impl sqlx::Type<sqlx::MySql> for InviteFlags {
+    fn type_info() -> sqlx::mysql::MySqlTypeInfo {
+        u64::type_info()
+    }
+}
+
+#[cfg(feature = "sqlx")]
+impl<'q> sqlx::Encode<'q, sqlx::MySql> for InviteFlags {
+    fn encode_by_ref(&self, buf: &mut <sqlx::MySql as sqlx::database::HasArguments<'q>>::ArgumentBuffer) -> sqlx::encode::IsNull {
+        u64::encode_by_ref(&self.0.0, buf)
+    }
+}
+
+#[cfg(feature = "sqlx")]
+impl<'r> sqlx::Decode<'r, sqlx::MySql> for InviteFlags {
+    fn decode(value: <sqlx::MySql as sqlx::database::HasValueRef<'r>>::ValueRef) -> Result<Self, sqlx::error::BoxDynError> {
+        let raw = u64::decode(value)?;
+
+        Ok(Self::from_bits(raw).unwrap())
     }
 }
 
 #[derive(Debug, Deserialize, Serialize, Clone, Copy, Default, PartialOrd, Ord, PartialEq, Eq)]
+#[cfg_attr(feature = "sqlx", derive(sqlx::Type))]
 #[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+#[repr(u8)]
 pub enum InviteType {
+    #[default]
+    Guild = 0,
+    GroupDm = 1,
+    Friend = 2,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone, Copy, Default, PartialOrd, Ord, PartialEq, Eq)]
+#[cfg_attr(feature = "sqlx", derive(sqlx::Type))]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+#[repr(u8)]
+pub enum InviteTargetType {
     #[default]
     Stream = 1,
     EmbeddedApplication = 2,