feat: add structs.rs

Moved all server related structs into new file, added implementations to create, fetch, etc.

src/api/v1/servers/mod.rs

@@ -1,35 +1,16 @@
-use actix_web::{error, post, web, Error, HttpRequest, HttpResponse, Scope};
+use actix_web::{post, web, Error, HttpRequest, HttpResponse, Scope};
-use futures::StreamExt;
+use serde::Deserialize;
-use log::error;
-use serde::{Deserialize, Serialize};
-use ::uuid::Uuid;
-use std::time::{SystemTime, UNIX_EPOCH};
 
 mod uuid;
 
-use crate::{api::v1::auth::check_access_token, utils::get_auth_header, Data};
+use crate::{api::v1::auth::check_access_token, structs::Guild, utils::get_auth_header, Data};
 
 #[derive(Deserialize)]
-struct Request {
+struct GuildInfo {
     name: String,
     description: Option<String>,
 }
 
-#[derive(Serialize)]
-struct Response {
-    guild_uuid: Uuid,
-}
-
-impl Response {
-    fn new(guild_uuid: Uuid) -> Self {
-        Self {
-            guild_uuid
-        }
-    }
-}
-
-const MAX_SIZE: usize = 262_144;
-
 pub fn web() -> Scope {
     web::scope("/servers")
         .service(res)
@@ -37,7 +18,7 @@ pub fn web() -> Scope {
 }
 
 #[post("")]
-pub async fn res(req: HttpRequest, mut payload: web::Payload, data: web::Data<Data>) -> Result<HttpResponse, Error> {
+pub async fn res(req: HttpRequest, guild_info: web::Json<GuildInfo>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers);
@@ -54,51 +35,12 @@ pub async fn res(req: HttpRequest, mut payload: web::Payload, data: web::Data<Da
 
     let uuid = authorized.unwrap();
 
-    let mut body = web::BytesMut::new();
+    let guild = Guild::new(&data.pool, guild_info.name.clone(), guild_info.description.clone(), uuid).await;
 
-    while let Some(chunk) = payload.next().await {
+    if let Err(error) = guild {
-        let chunk = chunk?;
+        return Ok(error)
-        // limit max size of in-memory payload
-        if (body.len() + chunk.len()) > MAX_SIZE {
-            return Err(error::ErrorBadRequest("overflow"));
-        }
-        body.extend_from_slice(&chunk);
     }
 
-    let request = serde_json::from_slice::<Request>(&body)?;
+    Ok(HttpResponse::Ok().json(guild.unwrap()))
-
-    let guild_uuid = Uuid::now_v7();
-
-    let row = sqlx::query(&format!("INSERT INTO guilds (uuid, owner_uuid, name, description) VALUES ('{}', '{}', $1, $2)", guild_uuid, uuid))
-        .bind(request.name)
-        .bind(request.description)
-        .execute(&data.pool)
-        .await;
-
-    if let Err(error) = row {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish())
-    }
-
-    let row = sqlx::query(&format!("INSERT INTO guild_members (uuid, guild_uuid, user_uuid) VALUES ('{}', '{}', '{}')", Uuid::now_v7(), guild_uuid, uuid))
-        .bind(SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs() as i64)
-        .execute(&data.pool)
-        .await;
-
-    if let Err(error) = row {
-        error!("{}", error);
-
-        let row = sqlx::query(&format!("DELETE FROM guilds WHERE uuid = '{}'", guild_uuid))
-            .execute(&data.pool)
-            .await;
-
-        if let Err(error) = row {
-            error!("{}", error);
-        }
-
-        return Ok(HttpResponse::InternalServerError().finish())
-    }
-
-    Ok(HttpResponse::Ok().json(Response::new(guild_uuid)))
 }
 

src/api/v1/servers/uuid/channels/mod.rs

@@ -1,102 +1,11 @@
-use std::str::FromStr;
-
 use actix_web::{get, post, web, Error, HttpRequest, HttpResponse};
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
-use sqlx::{prelude::FromRow, Pool, Postgres};
+use crate::{api::v1::auth::check_access_token, structs::{Channel, Member}, utils::get_auth_header, Data};
-use crate::{api::v1::auth::check_access_token, utils::get_auth_header, Data};
 use ::uuid::Uuid;
 use log::error;
 
 pub mod uuid;
 
-#[derive(Serialize, Clone, FromRow)]
-struct ChannelPermission {
-    role_uuid: String,
-    permissions: i32
-}
-
-#[derive(Serialize, Clone)]
-pub struct Channel {
-    uuid: String,
-    name: String,
-    description: Option<String>,
-    permissions: Vec<ChannelPermission>
-}
-
-impl Channel {
-    async fn fetch_all(pool: &Pool<Postgres>, guild_uuid: Uuid) -> Result<Vec<Self>, HttpResponse> {
-        let row = sqlx::query_as(&format!("SELECT CAST(uuid AS VARCHAR), name, description FROM channels WHERE guild_uuid = '{}'", guild_uuid))
-        .fetch_all(pool)
-        .await;
-
-        if let Err(error) = row {
-            error!("{}", error);
-
-            return Err(HttpResponse::InternalServerError().finish())
-        }
-
-        let channels: Vec<(String, String, Option<String>)> = row.unwrap();
-
-        let futures = channels.iter().map(async |t| {
-            let (uuid, name, description) = t.to_owned();
-
-            let row = sqlx::query_as(&format!("SELECT CAST(role_uuid AS VARCHAR), permissions FROM channel_permissions WHERE channel_uuid = '{}'", uuid))
-                .fetch_all(pool)
-                .await;
-
-            if let Err(error) = row {
-                error!("{}", error);
-
-                return Err(HttpResponse::InternalServerError().finish())
-            }
-
-            Ok(Self {
-                uuid,
-                name,
-                description,
-                permissions: row.unwrap(),
-            })
-        });
-
-        let channels = futures::future::join_all(futures).await;
-
-        let channels: Result<Vec<Channel>, HttpResponse> = channels.into_iter().collect();
-
-        Ok(channels?)
-    }
-
-    pub async fn fetch_one(pool: &Pool<Postgres>, guild_uuid: Uuid, channel_uuid: Uuid) -> Result<Self, HttpResponse> {
-        let row = sqlx::query_as(&format!("SELECT CAST(uuid AS VARCHAR), name, description FROM channels WHERE guild_uuid = '{}' AND uuid = '{}'", guild_uuid, channel_uuid))
-            .fetch_one(pool)
-            .await;
-
-        if let Err(error) = row {
-            error!("{}", error);
-
-            return Err(HttpResponse::InternalServerError().finish())
-        }
-
-        let (uuid, name, description): (String, String, Option<String>) = row.unwrap();
-
-        let row = sqlx::query_as(&format!("SELECT CAST(role_uuid AS VARCHAR), permissions FROM channel_permissions WHERE channel_uuid = '{}'", channel_uuid))
-            .fetch_all(pool)
-            .await;
-
-        if let Err(error) = row {
-            error!("{}", error);
-
-            return Err(HttpResponse::InternalServerError().finish())
-        }
-
-        Ok(Self {
-            uuid,
-            name,
-            description,
-            permissions: row.unwrap(),
-        })
-    }
-}
-
 #[derive(Deserialize)]
 struct ChannelInfo {
     name: String,
@@ -123,18 +32,12 @@ pub async fn response(req: HttpRequest, path: web::Path<(Uuid,)>, data: web::Dat
 
     let uuid = authorized.unwrap();
 
-    let row: Result<String, sqlx::Error> = sqlx::query_scalar(&format!("SELECT CAST(uuid AS VARCHAR) FROM guild_members WHERE guild_uuid = '{}' AND user_uuid = '{}'", guild_uuid, uuid))
+    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
-        .fetch_one(&data.pool)
-        .await;
 
-    if let Err(error) = row {
+    if let Err(error) = member {
-        error!("{}", error);
+        return Ok(error);
-
-        return Ok(HttpResponse::InternalServerError().finish())
     }
 
-    let _member_uuid = Uuid::from_str(&row.unwrap()).unwrap();
-
     let cache_result = data.get_cache_key(format!("{}_channels", guild_uuid)).await;
 
     if let Ok(cache_hit) = cache_result {
@@ -179,54 +82,19 @@ pub async fn response_post(req: HttpRequest, channel_info: web::Json<ChannelInfo
 
     let uuid = authorized.unwrap();
 
-    let row: Result<String, sqlx::Error> = sqlx::query_scalar(&format!("SELECT CAST(uuid AS VARCHAR) FROM guild_members WHERE guild_uuid = '{}' AND user_uuid = '{}'", guild_uuid, uuid))
+    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
-        .fetch_one(&data.pool)
-        .await;
 
-    if let Err(error) = row {
+    if let Err(error) = member {
-        error!("{}", error);
+        return Ok(error);
-
-        return Ok(HttpResponse::InternalServerError().finish())
     }
 
     // FIXME: Logic to check permissions, should probably be done in utils.rs
 
-    let _member_uuid = Uuid::from_str(&row.unwrap()).unwrap();
+    let channel = Channel::new(data.clone(), guild_uuid, channel_info.name.clone(), channel_info.description.clone()).await;
 
-    let channel_uuid = Uuid::now_v7();
+    if let Err(error) = channel {
-
+        return Ok(error);
-    let row = sqlx::query(&format!("INSERT INTO channels (uuid, guild_uuid, name, description) VALUES ('{}', '{}', $1, $2)", channel_uuid, guild_uuid))
-        .bind(&channel_info.name)
-        .bind(&channel_info.description)
-        .execute(&data.pool)
-        .await;
-
-    if let Err(error) = row {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish())
     }
 
-    let channel_result = Channel::fetch_one(&data.pool, guild_uuid, channel_uuid).await;
+    Ok(HttpResponse::Ok().json(channel.unwrap()))
-
-    if let Err(error) = channel_result {
-        return Ok(error)
-    }
-
-    let channel = channel_result.unwrap();
-
-    let cache_result = data.set_cache_key(channel_uuid.to_string(), channel.clone(), 1800).await;
-
-    if let Err(error) = cache_result {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
-
-    let cache_deletion_result = data.del_cache_key(format!("{}_channels", guild_uuid)).await;
-
-    if let Err(error) = cache_deletion_result {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
-
-    Ok(HttpResponse::Ok().json(channel))
 }

src/api/v1/servers/uuid/channels/uuid/mod.rs

@@ -1,11 +1,9 @@
 mod messages;
-use std::str::FromStr;
 
 use actix_web::{get, web, Error, HttpRequest, HttpResponse};
-use crate::{api::v1::auth::check_access_token, utils::get_auth_header, Data};
+use crate::{api::v1::auth::check_access_token, structs::{Channel, Member}, utils::get_auth_header, Data};
 use ::uuid::Uuid;
 use log::error;
-use super::Channel;
 
 #[get("{uuid}/channels/{channel_uuid}")]
 pub async fn res(req: HttpRequest, path: web::Path<(Uuid, Uuid)>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
@@ -27,18 +25,12 @@ pub async fn res(req: HttpRequest, path: web::Path<(Uuid, Uuid)>, data: web::Dat
 
     let uuid = authorized.unwrap();
 
-    let row: Result<String, sqlx::Error> = sqlx::query_scalar(&format!("SELECT CAST(uuid AS VARCHAR) FROM guild_members WHERE guild_uuid = '{}' AND user_uuid = '{}'", guild_uuid, uuid))
+    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
-        .fetch_one(&data.pool)
-        .await;
 
-    if let Err(error) = row {
+    if let Err(error) = member {
-        error!("{}", error);
+        return Ok(error);
-
-        return Ok(HttpResponse::InternalServerError().finish())
     }
 
-    let _member_uuid = Uuid::from_str(&row.unwrap()).unwrap();
-
     let cache_result = data.get_cache_key(format!("{}", channel_uuid)).await;
 
     if let Ok(cache_hit) = cache_result {

src/api/v1/servers/uuid/mod.rs

@@ -1,33 +1,9 @@
 use actix_web::{get, web, Error, HttpRequest, HttpResponse, Scope};
-use log::error;
-use serde::Serialize;
-use sqlx::FromRow;
 use uuid::Uuid;
-use std::str::FromStr;
 
 mod channels;
 
-use crate::{api::v1::auth::check_access_token, utils::get_auth_header, Data};
+use crate::{api::v1::auth::check_access_token, structs::{Guild, Member}, utils::get_auth_header, Data};
-
-#[derive(Serialize)]
-struct Response {
-    uuid: Uuid,
-    name: String,
-    description: Option<String>,
-    icon: String,
-    owner_uuid: Uuid,
-    roles: Vec<Role>,
-    member_count: i64,
-}
-
-#[derive(Serialize, FromRow)]
-struct Role {
-    uuid: String,
-    name: String,
-    color: i64,
-    position: i32,
-    permissions: i64,
-}
 
 pub fn web() -> Scope {
     web::scope("")
@@ -57,65 +33,18 @@ pub async fn res(req: HttpRequest, path: web::Path<(Uuid,)>, data: web::Data<Dat
 
     let uuid = authorized.unwrap();
 
-    let row: Result<String, sqlx::Error> = sqlx::query_scalar(&format!("SELECT CAST(uuid AS VARCHAR) FROM guild_members WHERE guild_uuid = '{}' AND user_uuid = '{}'", guild_uuid, uuid))
+    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
-        .fetch_one(&data.pool)
-        .await;
 
-    if let Err(error) = row {
+    if let Err(error) = member {
-        error!("{}", error);
+        return Ok(error);
-
-        return Ok(HttpResponse::InternalServerError().finish())
     }
 
-    let member_uuid = Uuid::from_str(&row.unwrap()).unwrap();
+    let guild = Guild::fetch_one(&data.pool, guild_uuid).await;
 
-    let row = sqlx::query_as(&format!("SELECT CAST(owner_uuid AS VARCHAR), name, description FROM guilds WHERE uuid = '{}'", guild_uuid))
+    if let Err(error) = guild {
-        .fetch_one(&data.pool)
+        return Ok(error);
-        .await;
-
-    if let Err(error) = row {
-        error!("{}", error);
-
-        return Ok(HttpResponse::InternalServerError().finish())
     }
 
-    let (owner_uuid_raw, name, description): (String, String, Option<String>) = row.unwrap();
+    Ok(HttpResponse::Ok().json(guild.unwrap()))
-
-    let owner_uuid = Uuid::from_str(&owner_uuid_raw).unwrap();
-
-    let row = sqlx::query_scalar(&format!("SELECT COUNT(uuid) FROM guild_members WHERE guild_uuid = '{}'", guild_uuid))
-        .fetch_one(&data.pool)
-        .await;
-
-    if let Err(error) = row {
-        error!("{}", error);
-
-        return Ok(HttpResponse::InternalServerError().finish())
-    }
-
-    let member_count: i64 = row.unwrap();
-
-    let roles_raw = sqlx::query_as(&format!("SELECT (uuid, name, color, position, permissions) FROM roles WHERE guild_uuid = '{}'", guild_uuid))
-        .fetch_all(&data.pool)
-        .await;
-
-    if let Err(error) = roles_raw {
-        error!("{}", error);
-
-        return Ok(HttpResponse::InternalServerError().finish())
-    }
-
-    let roles: Vec<Role> = roles_raw.unwrap();
-
-
-    Ok(HttpResponse::Ok().json(Response {
-        uuid,
-        name,
-        description,
-        icon: "bogus".to_string(),
-        owner_uuid,
-        roles,
-        member_count,
-    }))
 }
 

src/main.rs

@@ -10,6 +10,7 @@ use config::{Config, ConfigBuilder};
 mod api;
 
 pub mod utils;
+pub mod structs;
 
 type Error = Box<dyn std::error::Error>;
 
@@ -21,7 +22,7 @@ struct Args {
 }
 
 #[derive(Clone)]
-struct Data {
+pub struct Data {
     pub pool: Pool<Postgres>,
     pub cache_pool: redis::Client,
     pub _config: Config,

src/structs.rs

@@ -0,0 +1,351 @@
+use std::str::FromStr;
+
+use serde::Serialize;
+use sqlx::{prelude::FromRow, Pool, Postgres};
+use uuid::Uuid;
+use actix_web::HttpResponse;
+use log::error;
+
+use crate::Data;
+
+#[derive(Serialize, Clone)]
+pub struct Channel {
+    pub uuid: Uuid,
+    pub guild_uuid: Uuid,
+    name: String,
+    description: Option<String>,
+    pub permissions: Vec<ChannelPermission>
+}
+
+#[derive(Serialize, Clone, FromRow)]
+struct ChannelPermissionBuilder {
+    role_uuid: String,
+    permissions: i32
+}
+
+impl ChannelPermissionBuilder {
+    fn build(&self) -> ChannelPermission {
+        ChannelPermission {
+            role_uuid: Uuid::from_str(&self.role_uuid).unwrap(),
+            permissions: self.permissions,
+        }
+    }
+}
+
+#[derive(Serialize, Clone, FromRow)]
+pub struct ChannelPermission {
+    pub role_uuid: Uuid,
+    pub permissions: i32
+}
+
+impl Channel {
+    pub async fn fetch_all(pool: &Pool<Postgres>, guild_uuid: Uuid) -> Result<Vec<Self>, HttpResponse> {
+        let row = sqlx::query_as(&format!("SELECT CAST(uuid AS VARCHAR), name, description FROM channels WHERE guild_uuid = '{}'", guild_uuid))
+            .fetch_all(pool)
+            .await;
+
+        if let Err(error) = row {
+            error!("{}", error);
+
+            return Err(HttpResponse::InternalServerError().finish())
+        }
+
+        let channels: Vec<(String, String, Option<String>)> = row.unwrap();
+
+        let futures = channels.iter().map(async |t| {
+            let (uuid, name, description) = t.to_owned();
+
+            let row = sqlx::query_as(&format!("SELECT CAST(role_uuid AS VARCHAR), permissions FROM channel_permissions WHERE channel_uuid = '{}'", uuid))
+                .fetch_all(pool)
+                .await;
+
+            if let Err(error) = row {
+                error!("{}", error);
+
+                return Err(HttpResponse::InternalServerError().finish())
+            }
+
+            let channel_permission_builders: Vec<ChannelPermissionBuilder> = row.unwrap();
+
+            Ok(Self {
+                uuid: Uuid::from_str(&uuid).unwrap(),
+                guild_uuid,
+                name,
+                description,
+                permissions: channel_permission_builders.iter().map(|b| b.build()).collect(),
+            })
+        });
+
+        let channels = futures::future::join_all(futures).await;
+
+        let channels: Result<Vec<Channel>, HttpResponse> = channels.into_iter().collect();
+
+        Ok(channels?)
+    }
+
+    pub async fn fetch_one(pool: &Pool<Postgres>, guild_uuid: Uuid, channel_uuid: Uuid) -> Result<Self, HttpResponse> {
+        let row = sqlx::query_as(&format!("SELECT name, description FROM channels WHERE guild_uuid = '{}' AND uuid = '{}'", guild_uuid, channel_uuid))
+            .fetch_one(pool)
+            .await;
+
+        if let Err(error) = row {
+            error!("{}", error);
+
+            return Err(HttpResponse::InternalServerError().finish())
+        }
+
+        let (name, description): (String, Option<String>) = row.unwrap();
+
+        let row = sqlx::query_as(&format!("SELECT CAST(role_uuid AS VARCHAR), permissions FROM channel_permissions WHERE channel_uuid = '{}'", channel_uuid))
+            .fetch_all(pool)
+            .await;
+
+        if let Err(error) = row {
+            error!("{}", error);
+
+            return Err(HttpResponse::InternalServerError().finish())
+        }
+
+        let channel_permission_builders: Vec<ChannelPermissionBuilder> = row.unwrap();
+
+        Ok(Self {
+            uuid: channel_uuid,
+            guild_uuid,
+            name,
+            description,
+            permissions: channel_permission_builders.iter().map(|b| b.build()).collect(),
+        })
+    }
+
+    pub async fn new(data: actix_web::web::Data<Data>, guild_uuid: Uuid, name: String, description: Option<String>) -> Result<Self, HttpResponse> {
+        let channel_uuid = Uuid::now_v7();
+
+        let row = sqlx::query(&format!("INSERT INTO channels (uuid, guild_uuid, name, description) VALUES ('{}', '{}', $1, $2)", channel_uuid, guild_uuid))
+            .bind(&name)
+            .bind(&description)
+            .execute(&data.pool)
+            .await;
+    
+        if let Err(error) = row {
+            error!("{}", error);
+            return Err(HttpResponse::InternalServerError().finish())
+        }
+
+        let channel = Self {
+            uuid: channel_uuid,
+            guild_uuid,
+            name,
+            description,
+            permissions: vec![],
+        };
+
+        let cache_result = data.set_cache_key(channel_uuid.to_string(), channel.clone(), 1800).await;
+
+        if let Err(error) = cache_result {
+            error!("{}", error);
+            return Err(HttpResponse::InternalServerError().finish());
+        }
+
+        let cache_deletion_result = data.del_cache_key(format!("{}_channels", guild_uuid)).await;
+
+        if let Err(error) = cache_deletion_result {
+            error!("{}", error);
+            return Err(HttpResponse::InternalServerError().finish());
+        }
+
+        Ok(channel)
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum Permissions {
+    SendMessage = 1,
+    CreateChannel = 2,
+    DeleteChannel = 4,
+    ManageChannel = 8,
+    CreateRole = 16,
+    DeleteRole = 32,
+    ManageRole = 64,
+    CreateInvite = 128,
+    ManageInvite = 256,
+    ManageServer = 512,
+    ManageMember = 1024,
+}
+
+impl Permissions {
+    pub fn fetch_permissions(permissions: i64) -> Vec<Self> {
+        let all_perms = vec![
+            Self::SendMessage,
+            Self::CreateChannel,
+            Self::DeleteChannel,
+            Self::ManageChannel,
+            Self::CreateRole,
+            Self::DeleteRole,
+            Self::ManageRole,
+            Self::CreateInvite,
+            Self::ManageInvite,
+            Self::ManageServer,
+            Self::ManageMember,
+        ];
+
+        all_perms.into_iter()
+            .filter(|p| permissions & (*p as i64) != 0)
+            .collect()
+    }
+}
+
+#[derive(Serialize)]
+pub struct Guild {
+    pub uuid: Uuid,
+    name: String,
+    description: Option<String>,
+    icon: String,
+    owner_uuid: Uuid,
+    pub roles: Vec<Role>,
+    member_count: i64,
+}
+
+impl Guild {
+    pub async fn fetch_one(pool: &Pool<Postgres>, guild_uuid: Uuid) -> Result<Self, HttpResponse> {
+        let row = sqlx::query_as(&format!("SELECT CAST(owner_uuid AS VARCHAR), name, description FROM guilds WHERE uuid = '{}'", guild_uuid))
+            .fetch_one(pool)
+            .await;
+
+        if let Err(error) = row {
+            error!("{}", error);
+
+            return Err(HttpResponse::InternalServerError().finish())
+        }
+
+        let (owner_uuid_raw, name, description): (String, String, Option<String>) = row.unwrap();
+
+        let owner_uuid = Uuid::from_str(&owner_uuid_raw).unwrap();
+
+        let member_count = Member::count(pool, guild_uuid).await?;
+
+        let roles = Role::fetch_all(pool, guild_uuid).await?;
+
+        Ok(Self {
+            uuid: guild_uuid,
+            name,
+            description,
+            // FIXME: This isnt supposed to be bogus
+            icon: String::from("bogus"),
+            owner_uuid,
+            roles,
+            member_count,
+        })
+    }
+
+    pub async fn new(pool: &Pool<Postgres>, name: String, description: Option<String>, owner_uuid: Uuid) -> Result<Self, HttpResponse> {
+        let guild_uuid = Uuid::now_v7();
+
+        let row = sqlx::query(&format!("INSERT INTO guilds (uuid, owner_uuid, name, description) VALUES ('{}', '{}', $1, $2)", guild_uuid, owner_uuid))
+            .bind(&name)
+            .bind(&description)
+            .execute(pool)
+            .await;
+    
+        if let Err(error) = row {
+            error!("{}", error);
+            return Err(HttpResponse::InternalServerError().finish())
+        }
+    
+        let row = sqlx::query(&format!("INSERT INTO guild_members (uuid, guild_uuid, user_uuid) VALUES ('{}', '{}', '{}')", Uuid::now_v7(), guild_uuid, owner_uuid))
+            .execute(pool)
+            .await;
+    
+        if let Err(error) = row {
+            error!("{}", error);
+
+            let row = sqlx::query(&format!("DELETE FROM guilds WHERE uuid = '{}'", guild_uuid))
+                .execute(pool)
+                .await;
+
+            if let Err(error) = row {
+                error!("{}", error);
+            }
+
+            return Err(HttpResponse::InternalServerError().finish())
+        }
+
+        Ok(Guild {
+            uuid: guild_uuid,
+            name,
+            description,
+            icon: "bogus".to_string(),
+            owner_uuid,
+            roles: vec![],
+            member_count: 1
+        })
+    }
+}
+
+#[derive(Serialize, FromRow)]
+pub struct Role {
+    uuid: String,
+    name: String,
+    color: i64,
+    position: i32,
+    permissions: i64,
+}
+
+impl Role {
+    pub async fn fetch_all(pool: &Pool<Postgres>, guild_uuid: Uuid) -> Result<Vec<Self>, HttpResponse> {
+        let roles = sqlx::query_as(&format!("SELECT (uuid, name, color, position, permissions) FROM roles WHERE guild_uuid = '{}'", guild_uuid))
+            .fetch_all(pool)
+            .await;
+
+        if let Err(error) = roles {
+            error!("{}", error);
+
+            return Err(HttpResponse::InternalServerError().finish())
+        }
+
+        Ok(roles.unwrap())
+    }
+}
+
+pub struct Member {
+    pub uuid: Uuid,
+    pub nickname: String,
+    pub user_uuid: Uuid,
+    pub guild_uuid: Uuid,
+}
+
+impl Member {
+    async fn count(pool: &Pool<Postgres>, guild_uuid: Uuid) -> Result<i64, HttpResponse> {
+        let member_count = sqlx::query_scalar(&format!("SELECT COUNT(uuid) FROM guild_members WHERE guild_uuid = '{}'", guild_uuid))
+            .fetch_one(pool)
+            .await;
+
+        if let Err(error) = member_count {
+            error!("{}", error);
+
+            return Err(HttpResponse::InternalServerError().finish())
+        }
+
+        Ok(member_count.unwrap())
+    }
+
+    pub async fn fetch_one(pool: &Pool<Postgres>, user_uuid: Uuid, guild_uuid: Uuid) -> Result<Self, HttpResponse> {
+        let row = sqlx::query_as(&format!("SELECT CAST(uuid AS VARCHAR), nickname FROM guild_members WHERE guild_uuid = '{}' AND user_uuid = '{}'", guild_uuid, user_uuid))
+            .fetch_one(pool)
+            .await;
+
+        if let Err(error) = row {
+            error!("{}", error);
+
+            return Err(HttpResponse::InternalServerError().finish())
+        }
+
+        let (uuid, nickname): (String, String) = row.unwrap();
+
+        Ok(Member {
+            uuid: Uuid::from_str(&uuid).unwrap(),
+            nickname,
+            user_uuid,
+            guild_uuid,
+        })
+    }
+}

src/utils.rs

@@ -6,20 +6,6 @@ use serde::Serialize;
 
 use crate::Data;
 
-enum Permissions {
-    SendMessage = 1,
-    CreateChannel = 2,
-    DeleteChannel = 4,
-    ManageChannel = 8,
-    CreateRole = 16,
-    DeleteRole = 32,
-    ManageRole = 64,
-    CreateInvite = 128,
-    ManageInvite = 256,
-    ManageServer = 512,
-    ManageMember = 1024,
-}
-
 pub fn get_auth_header(headers: &HeaderMap) -> Result<&str, HttpResponse> {
     let auth_token = headers.get(actix_web::http::header::AUTHORIZATION);