Create Guild Ban (#398)

- Closes #299
- Add derives for `GuildCreateSchema`
- Add `GuildBanCreateSchema`
- Add `Guild::create_ban`

src/api/guilds/guilds.rs

@@ -7,8 +7,8 @@ use crate::errors::ChorusError;
 use crate::errors::ChorusResult;
 use crate::instance::UserMeta;
 use crate::ratelimiter::ChorusRequest;
-use crate::types::Snowflake;
-use crate::types::{Channel, ChannelCreateSchema, Guild, GuildCreateSchema};
+use crate::types::{Channel, ChannelCreateSchema, Guild, GuildBanCreateSchema, GuildCreateSchema};
+use crate::types::{GuildBan, Snowflake};
 
 impl Guild {
     /// Creates a new guild.
@@ -137,6 +137,30 @@ impl Guild {
         let response = chorus_request.deserialize_response::<Guild>(user).await?;
         Ok(response)
     }
+
+    pub async fn create_ban(
+        guild_id: Snowflake,
+        user_id: Snowflake,
+        schema: GuildBanCreateSchema,
+        user: &mut UserMeta,
+    ) -> ChorusResult<GuildBan> {
+        let chorus_request = ChorusRequest {
+            request: Client::new()
+                .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?;
+        Ok(response)
+    }
 }
 
 impl Channel {

src/types/schema/guild.rs

@@ -2,10 +2,10 @@ use serde::{Deserialize, Serialize};
 
 use crate::types::entities::Channel;
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
 #[serde(rename_all = "snake_case")]
 /// Represents the schema which needs to be sent to create a Guild.
-/// See: [https://docs.spacebar.chat/routes/#cmp--schemas-guildcreateschema](https://docs.spacebar.chat/routes/#cmp--schemas-guildcreateschema)
+/// See: <https://docs.spacebar.chat/routes/#cmp--schemas-guildcreateschema>
 pub struct GuildCreateSchema {
     pub name: Option<String>,
     pub region: Option<String>,
@@ -15,3 +15,12 @@ pub struct GuildCreateSchema {
     pub system_channel_id: Option<String>,
     pub rules_channel_id: Option<String>,
 }
+
+#[derive(Debug, Deserialize, Serialize, Default, Clone, Copy, Eq, PartialEq)]
+#[serde(rename_all = "snake_case")]
+/// Represents the schema which needs to be sent to create a Guild Ban.
+/// See: <https://discord-userdoccers.vercel.app/resources/guild#create-guild-ban>
+pub struct GuildBanCreateSchema {
+    pub delete_message_days: Option<u8>,
+    pub delete_message_seconds: Option<u32>,
+}

tests/guilds.rs

@@ -1,4 +1,4 @@
-use chorus::types::{Guild, GuildCreateSchema};
+use chorus::types::{CreateChannelInviteSchema, Guild, GuildBanCreateSchema, GuildCreateSchema};
 
 mod common;
 
@@ -31,3 +31,30 @@ async fn get_channels() {
     println!("{:?}", guild.channels(&mut bundle.user).await.unwrap());
     common::teardown(bundle).await;
 }
+
+#[tokio::test]
+async fn guild_create_ban() {
+    // TODO: When routes exist to check if user x is on guild y, add this as an assertion to check
+    // if Spacebar actually bans the user.
+    let mut bundle = common::setup().await;
+    let channel = bundle.channel.read().unwrap().clone();
+    let mut other_user = bundle.create_user("testuser1312").await;
+    let user = &mut bundle.user;
+    let create_channel_invite_schema = CreateChannelInviteSchema::default();
+    let guild = bundle.guild.read().unwrap().clone();
+    let invite = user
+        .create_channel_invite(create_channel_invite_schema, channel.id)
+        .await
+        .unwrap();
+    other_user.accept_invite(&invite.code, None).await.unwrap();
+    let other_user_id = other_user.object.read().unwrap().id;
+    Guild::create_ban(
+        guild.id,
+        other_user_id,
+        GuildBanCreateSchema::default(),
+        &mut bundle.user,
+    )
+    .await
+    .unwrap();
+    common::teardown(bundle).await
+}