src/api/v1/invites/id.rs

@@ -1,16 +1,27 @@
 use actix_web::{HttpRequest, HttpResponse, get, post, web};
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, structs::{Guild, Invite, Member}, utils::{get_auth_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{Guild, Invite, Member},
+    utils::get_auth_header,
 };
 
 #[get("{id}")]
 pub async fn get(
+    req: HttpRequest,
     path: web::Path<(String,)>,
     data: web::Data<Data>,
 ) -> Result<HttpResponse, Error> {
+    let headers = req.headers();
+
+    let auth_header = get_auth_header(headers)?;
+
     let mut conn = data.pool.get().await?;
 
+    check_access_token(auth_header, &mut conn).await?;
+
     let invite_id = path.into_inner().0;
 
     let invite = Invite::fetch_one(&mut conn, invite_id).await?;
@@ -36,8 +47,6 @@ pub async fn join(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
-
     let invite = Invite::fetch_one(&mut conn, invite_id).await?;
 
     let guild = Guild::fetch_one(&mut conn, invite.guild_uuid).await?;

src/api/v1/me/mod.rs

@@ -3,7 +3,7 @@ use actix_web::{HttpRequest, HttpResponse, Scope, get, patch, web};
 use serde::Deserialize;
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, structs::Me, utils::{get_auth_header, global_checks}, Data
+    Data, api::v1::auth::check_access_token, error::Error, structs::Me, utils::get_auth_header,
 };
 
 mod servers;
@@ -27,7 +27,7 @@ pub async fn get(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
     Ok(HttpResponse::Ok().json(me))
 }
 
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize)]
 struct NewInfo {
     username: Option<String>,
     display_name: Option<String>,
@@ -39,7 +39,7 @@ struct NewInfo {
 struct UploadForm {
     #[multipart(limit = "100MB")]
     avatar: Option<TempFile>,
-    json: MpJson<Option<NewInfo>>,
+    json: Option<MpJson<NewInfo>>,
 }
 
 #[patch("")]
@@ -56,10 +56,6 @@ pub async fn update(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    if form.avatar.is_some() || form.json.0.clone().is_some_and(|ni| ni.username.is_some() || ni.display_name.is_some()) {
-        global_checks(&data, uuid).await?;
-    }
-
     let mut me = Me::get(&mut conn, uuid).await?;
 
     if let Some(avatar) = form.avatar {
@@ -76,7 +72,7 @@ pub async fn update(
         .await?;
     }
 
-    if let Some(new_info) = form.json.0 {
+    if let Some(new_info) = form.json {
         if let Some(username) = &new_info.username {
             me.set_username(&mut conn, username.clone()).await?;
         }

src/api/v1/me/servers.rs

@@ -2,7 +2,7 @@
 
 use actix_web::{get, web, HttpRequest, HttpResponse};
 
-use crate::{api::v1::auth::check_access_token, error::Error, structs::Me, utils::{get_auth_header, global_checks}, Data};
+use crate::{api::v1::auth::check_access_token, error::Error, structs::Me, utils::get_auth_header, Data};
 
 
 /// `GET /api/v1/me/servers` Returns all guild memberships in a list
@@ -37,8 +37,6 @@ pub async fn get(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
-
     let me = Me::get(&mut conn, uuid).await?;
 
     let memberships = me.fetch_memberships(&mut conn).await?;

src/api/v1/servers/mod.rs

@@ -6,7 +6,11 @@ use serde::Deserialize;
 mod uuid;
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, structs::{Guild, StartAmountQuery}, utils::{get_auth_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{Guild, StartAmountQuery},
+    utils::get_auth_header,
 };
 
 #[derive(Deserialize)]
@@ -130,9 +134,7 @@ pub async fn get(
 
     let amount = request_query.amount.unwrap_or(10);
 
-    let uuid = check_access_token(auth_header, &mut data.pool.get().await?).await?;
+    check_access_token(auth_header, &mut data.pool.get().await?).await?;
-
-    global_checks(&data, uuid).await?;
 
     let guilds = Guild::fetch_amount(&data.pool, start, amount).await?;
 

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

@@ -1,5 +1,5 @@
 use crate::{
-    api::v1::auth::check_access_token, error::Error, structs::{Channel, Member}, utils::{get_auth_header, global_checks, order_by_is_above}, Data
+    api::v1::auth::check_access_token, error::Error, structs::{Channel, Member}, utils::{get_auth_header, order_by_is_above}, Data
 };
 use ::uuid::Uuid;
 use actix_web::{HttpRequest, HttpResponse, get, post, web};
@@ -29,8 +29,6 @@ pub async fn get(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
-
     Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
     if let Ok(cache_hit) = data.get_cache_key(format!("{}_channels", guild_uuid)).await {
@@ -70,8 +68,6 @@ pub async fn create(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
-
     Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
     // FIXME: Logic to check permissions, should probably be done in utils.rs

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

@@ -1,7 +1,11 @@
 //! `/api/v1/servers/{uuid}/channels/{uuid}/messages` Endpoints related to channel messages
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, structs::{Channel, Member}, utils::{get_auth_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{Channel, Member},
+    utils::get_auth_header,
 };
 use ::uuid::Uuid;
 use actix_web::{HttpRequest, HttpResponse, get, web};
@@ -60,8 +64,6 @@ pub async fn get(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
-
     Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
     let channel: Channel;

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

@@ -2,7 +2,11 @@ pub mod messages;
 pub mod socket;
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, structs::{Channel, Member}, utils::{get_auth_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{Channel, Member},
+    utils::get_auth_header,
 };
 use actix_web::{HttpRequest, HttpResponse, delete, get, web};
 use uuid::Uuid;
@@ -23,8 +27,6 @@ pub async fn get(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
-
     Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
     if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
@@ -57,8 +59,6 @@ pub async fn delete(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
-
     Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
     let channel: Channel;

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

@@ -8,7 +8,10 @@ use futures_util::StreamExt as _;
 use uuid::Uuid;
 
 use crate::{
-    api::v1::auth::check_access_token, structs::{Channel, Member}, utils::{get_ws_protocol_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    structs::{Channel, Member},
+    utils::get_ws_protocol_header,
 };
 
 #[get("{uuid}/channels/{channel_uuid}/socket")]
@@ -32,8 +35,6 @@ pub async fn ws(
     // Authorize client using auth header
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
-
     // Get server member from psql
     Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 

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

@@ -5,7 +5,11 @@ use futures_util::StreamExt as _;
 use uuid::Uuid;
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, structs::{Guild, Member}, utils::{get_auth_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{Guild, Member},
+    utils::get_auth_header,
 };
 
 /// `PUT /api/v1/servers/{uuid}/icon` Icon upload
@@ -30,8 +34,6 @@ pub async fn upload(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
-
     Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
     let mut guild = Guild::fetch_one(&mut conn, guild_uuid).await?;

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

@@ -3,7 +3,11 @@ use serde::Deserialize;
 use uuid::Uuid;
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, structs::{Guild, Member}, utils::{get_auth_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{Guild, Member},
+    utils::get_auth_header,
 };
 
 #[derive(Deserialize)]
@@ -27,8 +31,6 @@ pub async fn get(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
-
     Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
     let guild = Guild::fetch_one(&mut conn, guild_uuid).await?;
@@ -55,8 +57,6 @@ pub async fn create(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
-
     let member = Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
     let guild = Guild::fetch_one(&mut conn, guild_uuid).await?;

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

@@ -9,7 +9,11 @@ mod invites;
 mod roles;
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, structs::{Guild, Member}, utils::{get_auth_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{Guild, Member},
+    utils::get_auth_header,
 };
 
 pub fn web() -> Scope {
@@ -83,8 +87,6 @@ pub async fn get(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
-
     Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
     let guild = Guild::fetch_one(&mut conn, guild_uuid).await?;

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

@@ -3,7 +3,7 @@ use actix_web::{HttpRequest, HttpResponse, get, post, web};
 use serde::Deserialize;
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, structs::{Member, Role}, utils::{get_auth_header, global_checks, order_by_is_above}, Data
+    api::v1::auth::check_access_token, error::Error, structs::{Member, Role}, utils::{get_auth_header, order_by_is_above}, Data
 };
 
 pub mod uuid;
@@ -64,8 +64,6 @@ pub async fn create(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
-
     Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
     // FIXME: Logic to check permissions, should probably be done in utils.rs

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

@@ -1,5 +1,9 @@
 use crate::{
-    api::v1::auth::check_access_token, error::Error, structs::{Member, Role}, utils::{get_auth_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{Member, Role},
+    utils::get_auth_header,
 };
 use ::uuid::Uuid;
 use actix_web::{HttpRequest, HttpResponse, get, web};
@@ -20,8 +24,6 @@ pub async fn get(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
-
     Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
     if let Ok(cache_hit) = data.get_cache_key(format!("{}", role_uuid)).await {

src/api/v1/stats.rs

@@ -18,8 +18,6 @@ struct Response {
     accounts: i64,
     uptime: u64,
     version: String,
-    registration_enabled: bool,
-    email_verification_required: bool,
     build_number: String,
 }
 
@@ -33,8 +31,6 @@ struct Response {
 ///     "accounts": 3,
 ///     "uptime": 50000,
 ///     "version": "0.1.0",
-///     "registration_enabled": true,
-///     "email_verification_required": true,
 ///     "build_number": "39d01bb"
 /// });
 /// ```
@@ -54,8 +50,6 @@ pub async fn res(data: web::Data<Data>) -> Result<HttpResponse, Error> {
             .expect("Seriously why dont you have time??")
             .as_secs(),
         version: String::from(VERSION.unwrap_or("UNKNOWN")),
-        registration_enabled: data.config.instance.registration,
-        email_verification_required: data.config.instance.require_email_verification,
         // TODO: Get build number from git hash or remove this from the spec
         build_number: String::from("how do i implement this?"),
     };

src/api/v1/users/mod.rs

@@ -3,7 +3,11 @@
 use actix_web::{HttpRequest, HttpResponse, Scope, get, web};
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, structs::{StartAmountQuery, User}, utils::{get_auth_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{StartAmountQuery, User},
+    utils::get_auth_header,
 };
 
 mod uuid;
@@ -64,9 +68,7 @@ pub async fn get(
 
     let mut conn = data.pool.get().await?;
 
-    let uuid = check_access_token(auth_header, &mut conn).await?;
+    check_access_token(auth_header, &mut conn).await?;
-
-    global_checks(&data, uuid).await?;
 
     let users = User::fetch_amount(&mut conn, start, amount).await?;
 

src/api/v1/users/uuid.rs

@@ -4,7 +4,7 @@ use actix_web::{HttpRequest, HttpResponse, get, web};
 use uuid::Uuid;
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, structs::User, utils::{get_auth_header, global_checks}, Data
+    Data, api::v1::auth::check_access_token, error::Error, structs::User, utils::get_auth_header,
 };
 
 /// `GET /api/v1/users/{uuid}` Returns user with the given UUID
@@ -31,17 +31,15 @@ pub async fn get(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let user_uuid = path.into_inner().0;
+    let uuid = path.into_inner().0;
 
     let auth_header = get_auth_header(headers)?;
 
     let mut conn = data.pool.get().await?;
 
-    let uuid = check_access_token(auth_header, &mut conn).await?;
+    check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
+    let user = User::fetch_one(&data, uuid).await?;
-
-    let user = User::fetch_one(&data, user_uuid).await?;
 
     Ok(HttpResponse::Ok().json(user))
 }

src/config.rs

@@ -11,7 +11,7 @@ pub struct ConfigBuilder {
     database: Database,
     cache_database: CacheDatabase,
     web: WebBuilder,
-    instance: Option<InstanceBuilder>,
+    instance: Option<Instance>,
     bunny: BunnyBuilder,
     mail: Mail,
 }
@@ -42,10 +42,9 @@ struct WebBuilder {
     _ssl: Option<bool>,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, Clone)]
-struct InstanceBuilder {
+pub struct Instance {
-    registration: Option<bool>,
+    pub registration: bool,
-    require_email_verification: Option<bool>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -107,22 +106,11 @@ impl ConfigBuilder {
             cdn_url: self.bunny.cdn_url,
         };
 
-        let instance = match self.instance {
-            Some(instance) => Instance {
-                registration: instance.registration.unwrap_or(true),
-                require_email_verification: instance.require_email_verification.unwrap_or(false),
-            },
-            None => Instance {
-                registration: true,
-                require_email_verification: false,
-            },
-        };
-
         Config {
             database: self.database,
             cache_database: self.cache_database,
             web,
-            instance,
+            instance: self.instance.unwrap_or(Instance { registration: true }),
             bunny,
             mail: self.mail,
         }
@@ -146,12 +134,6 @@ pub struct Web {
     pub url: Url,
 }
 
-#[derive(Debug, Clone)]
-pub struct Instance {
-    pub registration: bool,
-    pub require_email_verification: bool,
-}
-
 #[derive(Debug, Clone)]
 pub struct Bunny {
     pub api_key: String,

src/structs.rs

@@ -16,7 +16,7 @@ use argon2::{
 };
 
 use crate::{
-    error::Error, schema::*, utils::{generate_refresh_token, global_checks, image_check, order_by_is_above, user_uuid_from_identifier, EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX}, Conn, Data
+    error::Error, schema::*, utils::{generate_refresh_token, image_check, order_by_is_above, user_uuid_from_identifier, EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX}, Conn, Data
 };
 
 pub trait HasUuid {
@@ -1070,8 +1070,6 @@ impl PasswordResetToken {
 
         let user_uuid = user_uuid_from_identifier(&mut conn, &identifier).await?;
 
-        global_checks(&data, user_uuid).await?;
-
         use users::dsl as udsl;
         let (username, email_address): (String, String) = udsl::users
             .filter(udsl::uuid.eq(user_uuid))

src/utils.rs

@@ -161,26 +161,6 @@ pub async fn user_uuid_from_identifier(conn: &mut Conn, identifier: &String) ->
     }
 }
 
-pub async fn global_checks(data: &Data, user_uuid: Uuid) -> Result<(), Error> {
-    if data.config.instance.require_email_verification {
-        let mut conn = data.pool.get().await?;
-
-        use users::dsl;
-        let email_verified: bool = dsl::users
-            .filter(dsl::uuid.eq(user_uuid))
-            .select(dsl::email_verified)
-            .get_result(&mut conn)
-            .await?;
-
-        if !email_verified {
-            return Err(Error::Forbidden("server requires email verification".to_string()))
-        }
-    }
-
-
-    Ok(())
-}
-
 pub async fn order_by_is_above<T>(mut items: Vec<T>) -> Result<Vec<T>, Error>
 where
     T: HasUuid + HasIsAbove,