Merge branch 'main' into improve-database-access

src/objects/member.rs

@@ -1,5 +1,6 @@
 use diesel::{
-    ExpressionMethods, Insertable, QueryDsl, Queryable, Selectable, SelectableHelper, insert_into,
+    ExpressionMethods, Insertable, QueryDsl, Queryable, Selectable, SelectableHelper, delete,
+    insert_into,
 };
 use diesel_async::RunQueryDsl;
 use serde::{Deserialize, Serialize};
@@ -8,8 +9,8 @@ use uuid::Uuid;
 use crate::{
     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};
@@ -124,6 +125,22 @@ impl Member {
         member.build(conn, cache_pool, Some(me)).await
     }
 
+    pub async fn fetch_one_with_member(
+        conn: &mut Conn,
+        cache_pool: &redis::Client,
+        me: Option<&Me>,
+        uuid: Uuid,
+    ) -> Result<Self, Error> {
+        use guild_members::dsl;
+        let member: MemberBuilder = dsl::guild_members
+            .filter(dsl::uuid.eq(uuid))
+            .select(MemberBuilder::as_select())
+            .get_result(conn)
+            .await?;
+
+        member.build(conn, cache_pool, me).await
+    }
+
     pub async fn fetch_all(
         conn: &mut Conn,
         cache_pool: &redis::Client,
@@ -154,6 +171,14 @@ impl Member {
         user_uuid: Uuid,
         guild_uuid: Uuid,
     ) -> Result<Self, Error> {
+        let banned = GuildBan::fetch_one(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 {
@@ -171,4 +196,36 @@ impl Member {
 
         member.build(conn, cache_pool, None).await
     }
+
+    pub async fn delete(self, conn: &mut Conn) -> Result<(), Error> {
+        if self.is_owner {
+            return Err(Error::Forbidden("Can not kick owner".to_string()))
+        }
+        delete(guild_members::table)
+            .filter(guild_members::uuid.eq(self.uuid))
+            .execute(conn)
+            .await?;
+
+        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(())
+    }
 }