style: move structs to objects and split into several files for readability

src/objects/me.rs

@@ -0,0 +1,232 @@
+use actix_web::web::BytesMut;
+use diesel::{ExpressionMethods, QueryDsl, Queryable, Selectable, SelectableHelper, update};
+use diesel_async::RunQueryDsl;
+use serde::Serialize;
+use tokio::task;
+use url::Url;
+use uuid::Uuid;
+
+use crate::{
+    Conn, Data,
+    error::Error,
+    schema::{guild_members, guilds, users},
+    utils::{EMAIL_REGEX, USERNAME_REGEX, image_check},
+};
+
+use super::{Guild, guild::GuildBuilder, load_or_empty, member::MemberBuilder};
+
+#[derive(Serialize, Queryable, Selectable)]
+#[diesel(table_name = users)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct Me {
+    pub uuid: Uuid,
+    pub username: String,
+    pub display_name: Option<String>,
+    avatar: Option<String>,
+    pronouns: Option<String>,
+    about: Option<String>,
+    pub email: String,
+    pub email_verified: bool,
+}
+
+impl Me {
+    pub async fn get(conn: &mut Conn, user_uuid: Uuid) -> Result<Self, Error> {
+        use users::dsl;
+        let me: Me = dsl::users
+            .filter(dsl::uuid.eq(user_uuid))
+            .select(Me::as_select())
+            .get_result(conn)
+            .await?;
+
+        Ok(me)
+    }
+
+    pub async fn fetch_memberships(&self, conn: &mut Conn) -> Result<Vec<Guild>, Error> {
+        use guild_members::dsl;
+        let memberships: Vec<MemberBuilder> = load_or_empty(
+            dsl::guild_members
+                .filter(dsl::user_uuid.eq(self.uuid))
+                .select(MemberBuilder::as_select())
+                .load(conn)
+                .await,
+        )?;
+
+        let mut guilds: Vec<Guild> = vec![];
+
+        for membership in memberships {
+            use guilds::dsl;
+            guilds.push(
+                dsl::guilds
+                    .filter(dsl::uuid.eq(membership.guild_uuid))
+                    .select(GuildBuilder::as_select())
+                    .get_result(conn)
+                    .await?
+                    .build(conn)
+                    .await?,
+            )
+        }
+
+        Ok(guilds)
+    }
+
+    pub async fn set_avatar(
+        &mut self,
+        data: &Data,
+        cdn_url: Url,
+        avatar: BytesMut,
+    ) -> Result<(), Error> {
+        let avatar_clone = avatar.clone();
+        let image_type = task::spawn_blocking(move || image_check(avatar_clone)).await??;
+
+        let mut conn = data.pool.get().await?;
+
+        if let Some(avatar) = &self.avatar {
+            let avatar_url: Url = avatar.parse()?;
+
+            let relative_url = avatar_url.path().trim_start_matches('/');
+
+            data.bunny_cdn.storage.delete(relative_url).await?;
+        }
+
+        let path = format!("avatar/{}/avatar.{}", self.uuid, image_type);
+
+        data.bunny_cdn
+            .storage
+            .upload(path.clone(), avatar.into())
+            .await?;
+
+        let avatar_url = cdn_url.join(&path)?;
+
+        use users::dsl;
+        update(users::table)
+            .filter(dsl::uuid.eq(self.uuid))
+            .set(dsl::avatar.eq(avatar_url.as_str()))
+            .execute(&mut conn)
+            .await?;
+
+        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
+            data.del_cache_key(self.uuid.to_string()).await?
+        }
+
+        self.avatar = Some(avatar_url.to_string());
+
+        Ok(())
+    }
+
+    pub async fn verify_email(&self, conn: &mut Conn) -> Result<(), Error> {
+        use users::dsl;
+        update(users::table)
+            .filter(dsl::uuid.eq(self.uuid))
+            .set(dsl::email_verified.eq(true))
+            .execute(conn)
+            .await?;
+
+        Ok(())
+    }
+
+    pub async fn set_username(&mut self, data: &Data, new_username: String) -> Result<(), Error> {
+        if !USERNAME_REGEX.is_match(&new_username) {
+            return Err(Error::BadRequest("Invalid username".to_string()));
+        }
+
+        let mut conn = data.pool.get().await?;
+
+        use users::dsl;
+        update(users::table)
+            .filter(dsl::uuid.eq(self.uuid))
+            .set(dsl::username.eq(new_username.as_str()))
+            .execute(&mut conn)
+            .await?;
+
+        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
+            data.del_cache_key(self.uuid.to_string()).await?
+        }
+
+        self.username = new_username;
+
+        Ok(())
+    }
+
+    pub async fn set_display_name(
+        &mut self,
+        data: &Data,
+        new_display_name: String,
+    ) -> Result<(), Error> {
+        let mut conn = data.pool.get().await?;
+
+        use users::dsl;
+        update(users::table)
+            .filter(dsl::uuid.eq(self.uuid))
+            .set(dsl::display_name.eq(new_display_name.as_str()))
+            .execute(&mut conn)
+            .await?;
+
+        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
+            data.del_cache_key(self.uuid.to_string()).await?
+        }
+
+        self.display_name = Some(new_display_name);
+
+        Ok(())
+    }
+
+    pub async fn set_email(&mut self, data: &Data, new_email: String) -> Result<(), Error> {
+        if !EMAIL_REGEX.is_match(&new_email) {
+            return Err(Error::BadRequest("Invalid username".to_string()));
+        }
+
+        let mut conn = data.pool.get().await?;
+
+        use users::dsl;
+        update(users::table)
+            .filter(dsl::uuid.eq(self.uuid))
+            .set((
+                dsl::email.eq(new_email.as_str()),
+                dsl::email_verified.eq(false),
+            ))
+            .execute(&mut conn)
+            .await?;
+
+        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
+            data.del_cache_key(self.uuid.to_string()).await?
+        }
+
+        self.email = new_email;
+
+        Ok(())
+    }
+
+    pub async fn set_pronouns(&mut self, data: &Data, new_pronouns: String) -> Result<(), Error> {
+        let mut conn = data.pool.get().await?;
+
+        use users::dsl;
+        update(users::table)
+            .filter(dsl::uuid.eq(self.uuid))
+            .set((dsl::pronouns.eq(new_pronouns.as_str()),))
+            .execute(&mut conn)
+            .await?;
+
+        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
+            data.del_cache_key(self.uuid.to_string()).await?
+        }
+
+        Ok(())
+    }
+
+    pub async fn set_about(&mut self, data: &Data, new_about: String) -> Result<(), Error> {
+        let mut conn = data.pool.get().await?;
+
+        use users::dsl;
+        update(users::table)
+            .filter(dsl::uuid.eq(self.uuid))
+            .set((dsl::about.eq(new_about.as_str()),))
+            .execute(&mut conn)
+            .await?;
+
+        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
+            data.del_cache_key(self.uuid.to_string()).await?
+        }
+
+        Ok(())
+    }
+}