More Guild Routes (#411)

src/api/guilds/guilds.rs

@@ -8,8 +8,9 @@ use crate::errors::ChorusResult;
 use crate::instance::ChorusUser;
 use crate::ratelimiter::ChorusRequest;
 use crate::types::{
-    Channel, ChannelCreateSchema, Guild, GuildBanCreateSchema, GuildCreateSchema, GuildMember,
-    GuildMemberSearchSchema, GuildModifySchema, GuildPreview,
+    Channel, ChannelCreateSchema, Guild, GuildBanCreateSchema, GuildBansQuery, GuildCreateSchema,
+    GuildMember, GuildMemberSearchSchema, GuildModifySchema, GuildPreview,
+    ModifyGuildMemberProfileSchema, ModifyGuildMemberSchema, UserProfileMetadata,
 };
 use crate::types::{GuildBan, Snowflake};
 
@@ -145,24 +146,26 @@ impl Guild {
     pub async fn create_ban(
         guild_id: Snowflake,
         user_id: Snowflake,
+        audit_log_reason: Option<String>,
         schema: GuildBanCreateSchema,
         user: &mut ChorusUser,
     ) -> ChorusResult<GuildBan> {
-        let chorus_request = ChorusRequest {
-            request: Client::new()
-                .put(format!(
+        let request = ChorusRequest::new(
+            http::Method::PUT,
+            format!(
                 "{}/guilds/{}/bans/{}",
                 user.belongs_to.borrow().urls.api,
                 guild_id,
                 user_id
-                ))
-                .header("Authorization", user.token())
-                .body(to_string(&schema).unwrap()),
-            limit_type: LimitType::Guild(guild_id),
-        };
-        let response = chorus_request
-            .deserialize_response::<GuildBan>(user)
-            .await?;
+            )
+            .as_str(),
+            Some(to_string(&schema).unwrap()),
+            audit_log_reason.as_deref(),
+            None,
+            Some(user),
+            LimitType::Guild(guild_id),
+        );
+        let response = request.deserialize_response::<GuildBan>(user).await?;
         Ok(response)
     }
 
@@ -295,6 +298,178 @@ impl Guild {
         );
         request.handle_request_as_result(user).await
     }
+
+    /// Modifies attributes of a guild member. Returns the updated guild member object on success.
+    /// For required Permissions and an API reference, see:
+    ///
+    /// # Reference:
+    /// <https://discord-userdoccers.vercel.app/resources/guild#modify-guild-member>
+    pub async fn modify_member(
+        guild_id: Snowflake,
+        member_id: Snowflake,
+        schema: ModifyGuildMemberSchema,
+        audit_log_reason: Option<String>,
+        user: &mut ChorusUser,
+    ) -> ChorusResult<GuildMember> {
+        let request = ChorusRequest::new(
+            http::Method::PATCH,
+            format!(
+                "{}/guilds/{}/members/{}",
+                user.belongs_to.borrow().urls.api,
+                guild_id,
+                member_id,
+            )
+            .as_str(),
+            Some(to_string(&schema).unwrap()),
+            audit_log_reason.as_deref(),
+            None,
+            Some(user),
+            LimitType::Guild(guild_id),
+        );
+        request.deserialize_response::<GuildMember>(user).await
+    }
+
+    /// Modifies the current user's member in the guild.
+    ///
+    /// # Reference:
+    /// See <https://discord-userdoccers.vercel.app/resources/guild#modify-current-guild-member>
+    pub async fn modify_current_member(
+        guild_id: Snowflake,
+        schema: ModifyGuildMemberSchema,
+        audit_log_reason: Option<String>,
+        user: &mut ChorusUser,
+    ) -> ChorusResult<GuildMember> {
+        let request = ChorusRequest::new(
+            http::Method::PATCH,
+            format!(
+                "{}/guilds/{}/members/@me",
+                user.belongs_to.borrow().urls.api,
+                guild_id,
+            )
+            .as_str(),
+            Some(to_string(&schema).unwrap()),
+            audit_log_reason.as_deref(),
+            None,
+            Some(user),
+            LimitType::Guild(guild_id),
+        );
+        request.deserialize_response::<GuildMember>(user).await
+    }
+
+    /// Modifies the current user's profile in the guild.
+    ///
+    /// # Reference:
+    /// See <https://discord-userdoccers.vercel.app/resources/guild#modify-guild-member-profile>
+    pub async fn modify_member_profile(
+        guild_id: Snowflake,
+        schema: ModifyGuildMemberProfileSchema,
+        user: &mut ChorusUser,
+    ) -> ChorusResult<UserProfileMetadata> {
+        let request = ChorusRequest::new(
+            http::Method::PATCH,
+            format!(
+                "{}/guilds/{}/profile/@me",
+                user.belongs_to.borrow().urls.api,
+                guild_id,
+            )
+            .as_str(),
+            Some(to_string(&schema).unwrap()),
+            None,
+            None,
+            Some(user),
+            LimitType::Guild(guild_id),
+        );
+        request
+            .deserialize_response::<UserProfileMetadata>(user)
+            .await
+    }
+
+    /// Returns a list of ban objects for the guild. Requires the `BAN_MEMBERS` permission.
+    ///
+    /// # Reference:
+    /// See <https://discord-userdoccers.vercel.app/resources/guild#get-guild-bans>
+    pub async fn get_bans(
+        user: &mut ChorusUser,
+        guild_id: Snowflake,
+        query: Option<GuildBansQuery>,
+    ) -> ChorusResult<Vec<GuildBan>> {
+        let url = format!(
+            "{}/guilds/{}/bans",
+            user.belongs_to.borrow_mut().urls.api,
+            guild_id,
+        );
+
+        let mut request = ChorusRequest::new(
+            http::Method::GET,
+            &url,
+            None,
+            None,
+            None,
+            Some(user),
+            LimitType::Guild(guild_id),
+        );
+        if let Some(query) = query {
+            request.request = request.request.query(&to_string(&query).unwrap());
+        }
+        request.deserialize_response::<Vec<GuildBan>>(user).await
+    }
+
+    /// Returns a ban object for the given user. Requires the `BAN_MEMBERS` permission.
+    ///
+    /// # Reference:
+    /// See <https://discord-userdoccers.vercel.app/resources/guild#get-guild-ban>
+    pub async fn get_ban(
+        user: &mut ChorusUser,
+        guild_id: Snowflake,
+        user_id: Snowflake,
+    ) -> ChorusResult<GuildBan> {
+        let url = format!(
+            "{}/guilds/{}/bans/{}",
+            user.belongs_to.borrow_mut().urls.api,
+            guild_id,
+            user_id
+        );
+
+        let request = ChorusRequest::new(
+            http::Method::GET,
+            &url,
+            None,
+            None,
+            None,
+            Some(user),
+            LimitType::Guild(guild_id),
+        );
+        request.deserialize_response::<GuildBan>(user).await
+    }
+
+    /// Removes the ban for a user. Requires the BAN_MEMBERS permissions. Returns a 204 empty response on success.
+    ///
+    /// # Reference:
+    /// See <https://discord-userdoccers.vercel.app/resources/guild#delete-guild-ban>
+    pub async fn delete_ban(
+        user: &mut ChorusUser,
+        guild_id: Snowflake,
+        user_id: Snowflake,
+        audit_log_reason: Option<String>,
+    ) -> ChorusResult<()> {
+        let url = format!(
+            "{}/guilds/{}/bans/{}",
+            user.belongs_to.borrow_mut().urls.api,
+            guild_id,
+            user_id
+        );
+
+        let request = ChorusRequest::new(
+            http::Method::DELETE,
+            &url,
+            None,
+            audit_log_reason.as_deref(),
+            None,
+            Some(user),
+            LimitType::Guild(guild_id),
+        );
+        request.handle_request_as_result(user).await
+    }
 }
 
 impl Channel {

src/types/entities/user.rs

@@ -7,6 +7,8 @@ use std::fmt::Debug;
 use crate::gateway::{GatewayHandle, Updateable};
 use crate::types::{utils::Snowflake, Composite};
 
+use super::Emoji;
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
 #[cfg_attr(feature = "sqlx", derive(sqlx::Type))]
 pub struct UserData {
@@ -120,3 +122,15 @@ bitflags::bitflags! {
         const BOT_HTTP_INTERACTIONS = 1 << 19;
     }
 }
+
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, PartialOrd)]
+pub struct UserProfileMetadata {
+    pub guild_id: Option<Snowflake>,
+    pub pronouns: String,
+    pub bio: Option<String>,
+    pub banner: Option<String>,
+    pub accent_color: Option<i32>,
+    pub theme_colors: Option<Vec<i32>>,
+    pub popout_animation_particle_type: Option<Snowflake>,
+    pub emoji: Option<Emoji>,
+}

src/types/schema/guild.rs

@@ -1,3 +1,5 @@
+use bitflags::bitflags;
+use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 
 use crate::types::entities::Channel;
@@ -106,3 +108,58 @@ impl Default for GuildMemberSearchSchema {
         }
     }
 }
+
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, PartialOrd, Eq, Ord)]
+pub struct ModifyGuildMemberSchema {
+    pub nick: Option<String>,
+    pub roles: Option<Vec<Snowflake>>,
+    pub mute: Option<bool>,
+    pub deaf: Option<bool>,
+    pub channel_id: Option<Snowflake>,
+    pub communication_disabled_until: Option<DateTime<Utc>>,
+    pub flags: Option<GuildMemberFlags>,
+}
+
+bitflags! {
+    #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord)]
+    /// Represents the flags of a Guild Member.
+    ///
+    /// # Reference:
+    /// See <https://discord-userdoccers.vercel.app/resources/guild#guild-member-flags>
+    pub struct GuildMemberFlags: u64 {
+        const DID_REJOIN = 1 << 0;
+        const COMPLETED_ONBOARDING = 1 << 1;
+        const BYPASSES_VERIFICATION = 1 << 2;
+        const STARTED_ONBOARDING = 1 << 3;
+        const GUEST = 1 << 3;
+        const AUTOMOD_QUARANTINED_NAME = 1 << 7;
+        const AUTOMOD_QUARANTINED_BIO = 1 << 8;
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, PartialOrd, Eq, Ord)]
+pub struct ModifyCurrentGuildMemberSchema {
+    pub nick: Option<String>,
+    pub avatar: Option<String>,
+    pub bio: Option<String>,
+    pub banner: Option<String>,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, PartialOrd, Eq, Ord)]
+pub struct ModifyGuildMemberProfileSchema {
+    pub pronouns: Option<String>,
+    pub bio: Option<String>,
+    pub banner: Option<String>,
+    pub accent_color: Option<String>,
+    pub theme_colors: Option<Vec<i32>>,
+    pub popout_animation_particle_type: Option<Snowflake>,
+    pub emoji_id: Option<Snowflake>,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, PartialOrd, Eq, Ord)]
+/// The limit argument is a number between 1 and 1000.
+pub struct GuildBansQuery {
+    pub before: Option<Snowflake>,
+    pub after: Option<Snowflake>,
+    pub limit: Option<u16>,
+}

tests/guilds.rs

@@ -53,6 +53,7 @@ async fn guild_create_ban() {
     Guild::create_ban(
         guild.id,
         other_user_id,
+        None,
         GuildBanCreateSchema::default(),
         &mut bundle.user,
     )
@@ -61,6 +62,7 @@ async fn guild_create_ban() {
     assert!(Guild::create_ban(
         guild.id,
         other_user_id,
+        None,
         GuildBanCreateSchema::default(),
         &mut bundle.user,
     )