Merge branch 'wip/ban'

src/objects/bans.rs

@@ -0,0 +1,57 @@
+use diesel::{ExpressionMethods, QueryDsl, Queryable, Selectable, SelectableHelper};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use diesel_async::RunQueryDsl;
+
+use crate::{Conn, error::Error, objects::load_or_empty, schema::guild_bans};
+
+#[derive(Selectable, Queryable, Serialize, Deserialize)]
+#[diesel(table_name = guild_bans)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct GuildBan {
+    pub guild_uuid: Uuid,
+    pub user_uuid: Uuid,
+    pub reason: Option<String>,
+    pub banned_since: chrono::DateTime<chrono::Utc>,
+}
+
+impl GuildBan {
+    pub async fn fetch_one(
+        conn: &mut Conn,
+        guild_uuid: Uuid,
+        user_uuid: Uuid,
+    ) -> Result<GuildBan, Error> {
+        use guild_bans::dsl;
+        let guild_ban = dsl::guild_bans
+            .filter(dsl::guild_uuid.eq(guild_uuid))
+            .filter(dsl::user_uuid.eq(user_uuid))
+            .select(GuildBan::as_select())
+            .get_result(conn)
+            .await?;
+
+        Ok(guild_ban)
+    }
+
+    pub async fn fetch_all(conn: &mut Conn, guild_uuid: Uuid) -> Result<Vec<Self>, Error> {
+        use guild_bans::dsl;
+        let all_guild_bans = load_or_empty(
+            dsl::guild_bans
+                .filter(dsl::guild_uuid.eq(guild_uuid))
+                .load(conn)
+                .await,
+        )?;
+
+        Ok(all_guild_bans)
+    }
+
+    pub async fn unban(self, conn: &mut Conn) -> Result<(), Error> {
+        use guild_bans::dsl;
+        diesel::delete(guild_bans::table)
+            .filter(dsl::guild_uuid.eq(self.guild_uuid))
+            .filter(dsl::user_uuid.eq(self.user_uuid))
+            .execute(conn)
+            .await?;
+        Ok(())
+    }
+}

src/objects/member.rs

@@ -9,8 +9,8 @@ use uuid::Uuid;
 use crate::{
     AppState, Conn,
     error::Error,
-    objects::{Me, Permissions, Role},
-    schema::guild_members,
+    objects::{GuildBan, Me, Permissions, Role},
+    schema::{guild_bans, guild_members},
 };
 
 use super::{User, load_or_empty};
@@ -122,7 +122,7 @@ impl Member {
 
     pub async fn fetch_one_with_member(
         app_state: &AppState,
-        me: &Me,
+        me: Option<&Me>,
         uuid: Uuid,
     ) -> Result<Self, Error> {
         let mut conn = app_state.pool.get().await?;
@@ -134,7 +134,7 @@ impl Member {
             .get_result(&mut conn)
             .await?;
 
-        member.build(app_state, Some(me)).await
+        member.build(app_state, me).await
     }
 
     pub async fn fetch_all(
@@ -169,6 +169,13 @@ impl Member {
     ) -> Result<Self, Error> {
         let mut conn = app_state.pool.get().await?;
 
+        let banned = GuildBan::fetch_one(&mut conn, guild_uuid, user_uuid).await;
+        match banned {
+            Ok(_) => Err(Error::Forbidden("User banned".to_string())),
+            Err(Error::SqlError(diesel::result::Error::NotFound)) => Ok(()),
+            Err(e) => Err(e),
+        }?;
+
         let member_uuid = Uuid::now_v7();
 
         let member = MemberBuilder {
@@ -198,4 +205,24 @@ impl Member {
 
         Ok(())
     }
+
+    pub async fn ban(self, conn: &mut Conn, reason: &String) -> Result<(), Error> {
+        if self.is_owner {
+            return Err(Error::Forbidden("Can not ban owner".to_string()));
+        }
+
+        use guild_bans::dsl;
+        insert_into(guild_bans::table)
+            .values((
+                dsl::guild_uuid.eq(self.guild_uuid),
+                dsl::user_uuid.eq(self.user_uuid),
+                dsl::reason.eq(reason),
+            ))
+            .execute(conn)
+            .await?;
+
+        self.delete(conn).await?;
+
+        Ok(())
+    }
 }

src/objects/mod.rs

@@ -7,6 +7,7 @@ use log::debug;
 use serde::Deserialize;
 use uuid::Uuid;
 
+mod bans;
 mod channel;
 mod email_token;
 mod friends;
@@ -19,6 +20,7 @@ mod password_reset_token;
 mod role;
 mod user;
 
+pub use bans::GuildBan;
 pub use channel::Channel;
 pub use email_token::EmailToken;
 pub use friends::Friend;

src/objects/role.rs

@@ -176,6 +176,8 @@ pub enum Permissions {
     ManageGuild = 32,
     /// Lets users change member settings (nickname, etc)
     ManageMember = 64,
+    /// Lets users ban members
+    BanMember = 128,
     /// Lets users kick members
     KickMember = 256,
 }
@@ -190,6 +192,7 @@ impl Permissions {
             Self::ManageInvite,
             Self::ManageGuild,
             Self::ManageMember,
+            Self::BanMember,
             Self::KickMember,
         ];