feat: migrate to diesel and new error type in servers

src/api/v1/servers/mod.rs

@@ -1,9 +1,9 @@
-use actix_web::{get, post, web, Error, HttpRequest, HttpResponse, Scope};
+use actix_web::{get, post, web, HttpRequest, HttpResponse, Scope};
 use serde::Deserialize;
 
 mod uuid;
 
-use crate::{api::v1::auth::check_access_token, structs::{Guild, StartAmountQuery}, utils::get_auth_header, Data};
+use crate::{error::Error, api::v1::auth::check_access_token, structs::{Guild, StartAmountQuery}, utils::get_auth_header, Data};
 
 #[derive(Deserialize)]
 struct GuildInfo {
@@ -26,33 +26,21 @@ pub async fn create(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
 
-    if let Err(error) = auth_header {
+    let mut conn = data.pool.get().await?;
-        return Ok(error);
-    }
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    if let Err(error) = authorized {
-        return Ok(error);
-    }
-
-    let uuid = authorized.unwrap();
 
     let guild = Guild::new(
-        &data.pool,
+        &mut conn,
         guild_info.name.clone(),
         guild_info.description.clone(),
         uuid,
     )
-    .await;
+    .await?;
 
-    if let Err(error) = guild {
+    Ok(HttpResponse::Ok().json(guild))
-        return Ok(error);
-    }
-
-    Ok(HttpResponse::Ok().json(guild.unwrap()))
 }
 
 #[get("")]
@@ -63,28 +51,16 @@ pub async fn get(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
 
     let start = request_query.start.unwrap_or(0);
 
     let amount = request_query.amount.unwrap_or(10);
 
-    if let Err(error) = auth_header {
+    check_access_token(auth_header, &mut data.pool.get().await.unwrap()).await?;
-        return Ok(error);
-    }
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let guilds = Guild::fetch_amount(&data.pool, start, amount).await?;
 
-    if let Err(error) = authorized {
+    Ok(HttpResponse::Ok().json(guilds))
-        return Ok(error);
-    }
-
-    let guilds = Guild::fetch_amount(&data.pool, start, amount).await;
-
-    if let Err(error) = guilds {
-        return Ok(error);
-    }
-
-    Ok(HttpResponse::Ok().json(guilds.unwrap()))
 }
 

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

@@ -1,12 +1,12 @@
 use crate::{
+    error::Error,
     Data,
     api::v1::auth::check_access_token,
     structs::{Channel, Member},
     utils::get_auth_header,
 };
 use ::uuid::Uuid;
-use actix_web::{Error, HttpRequest, HttpResponse, get, post, web};
+use actix_web::{HttpRequest, HttpResponse, get, post, web};
-use log::error;
 use serde::Deserialize;
 
 pub mod uuid;
@@ -25,52 +25,27 @@ pub async fn get(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let guild_uuid = path.into_inner().0;
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}_channels", guild_uuid)).await {
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
-
-    let cache_result = data.get_cache_key(format!("{}_channels", guild_uuid)).await;
-
-    if let Ok(cache_hit) = cache_result {
         return Ok(HttpResponse::Ok()
             .content_type("application/json")
             .body(cache_hit));
     }
 
-    let channels_result = Channel::fetch_all(&data.pool, guild_uuid).await;
+    let channels = Channel::fetch_all(&data.pool, guild_uuid).await?;
 
-    if let Err(error) = channels_result {
+    data
-        return Ok(error);
-    }
-
-    let channels = channels_result.unwrap();
-
-    let cache_result = data
         .set_cache_key(format!("{}_channels", guild_uuid), channels.clone(), 1800)
-        .await;
+        .await?;
-
-    if let Err(error) = cache_result {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
 
     Ok(HttpResponse::Ok().json(channels))
 }
@@ -84,27 +59,15 @@ pub async fn create(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let guild_uuid = path.into_inner().0;
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
-
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
 
     // FIXME: Logic to check permissions, should probably be done in utils.rs
 
@@ -116,9 +79,5 @@ pub async fn create(
     )
     .await;
 
-    if let Err(error) = channel {
-        return Ok(error);
-    }
-
     Ok(HttpResponse::Ok().json(channel.unwrap()))
 }

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

@@ -1,12 +1,12 @@
 use crate::{
+    error::Error,
     Data,
     api::v1::auth::check_access_token,
     structs::{Channel, Member},
     utils::get_auth_header,
 };
 use ::uuid::Uuid;
-use actix_web::{Error, HttpRequest, HttpResponse, get, web};
+use actix_web::{HttpRequest, HttpResponse, get, web};
-use log::error;
 use serde::Deserialize;
 
 #[derive(Deserialize)]
@@ -24,60 +24,31 @@ pub async fn get(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let (guild_uuid, channel_uuid) = path.into_inner();
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
-
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
-
-    let cache_result = data.get_cache_key(format!("{}", channel_uuid)).await;
 
     let channel: Channel;
 
-    if let Ok(cache_hit) = cache_result {
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
-        channel = serde_json::from_str(&cache_hit).unwrap()
+        channel = serde_json::from_str(&cache_hit)?
     } else {
-        let channel_result = Channel::fetch_one(&data.pool, guild_uuid, channel_uuid).await;
+        channel = Channel::fetch_one(&mut conn, channel_uuid).await?;
 
-        if let Err(error) = channel_result {
+        data
-            return Ok(error);
-        }
-
-        channel = channel_result.unwrap();
-
-        let cache_result = data
             .set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
-            .await;
+            .await?;
-
-        if let Err(error) = cache_result {
-            error!("{}", error);
-            return Ok(HttpResponse::InternalServerError().finish());
-        }
     }
 
     let messages = channel
-        .fetch_messages(&data.pool, message_request.amount, message_request.offset)
+        .fetch_messages(&mut conn, message_request.amount, message_request.offset)
-        .await;
+        .await?;
 
-    if let Err(error) = messages {
+    Ok(HttpResponse::Ok().json(messages))
-        return Ok(error);
-    }
-
-    Ok(HttpResponse::Ok().json(messages.unwrap()))
 }

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

@@ -2,14 +2,14 @@ pub mod messages;
 pub mod socket;
 
 use crate::{
+    error::Error,
     Data,
     api::v1::auth::check_access_token,
     structs::{Channel, Member},
     utils::get_auth_header,
 };
-use ::uuid::Uuid;
+use uuid::Uuid;
-use actix_web::{Error, HttpRequest, HttpResponse, delete, get, web};
+use actix_web::{HttpRequest, HttpResponse, delete, get, web};
-use log::error;
 
 #[get("{uuid}/channels/{channel_uuid}")]
 pub async fn get(
@@ -19,52 +19,27 @@ pub async fn get(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let (guild_uuid, channel_uuid) = path.into_inner();
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
-
-    let cache_result = data.get_cache_key(format!("{}", channel_uuid)).await;
-
-    if let Ok(cache_hit) = cache_result {
         return Ok(HttpResponse::Ok()
             .content_type("application/json")
             .body(cache_hit));
     }
 
-    let channel_result = Channel::fetch_one(&data.pool, guild_uuid, channel_uuid).await;
+    let channel = Channel::fetch_one(&mut conn, channel_uuid).await?;
 
-    if let Err(error) = channel_result {
+    data
-        return Ok(error);
-    }
-
-    let channel = channel_result.unwrap();
-
-    let cache_result = data
         .set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
-        .await;
+        .await?;
-
-    if let Err(error) = cache_result {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
 
     Ok(HttpResponse::Ok().json(channel))
 }
@@ -77,55 +52,27 @@ pub async fn delete(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let (guild_uuid, channel_uuid) = path.into_inner();
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
-
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
-
-    let cache_result = data.get_cache_key(format!("{}", channel_uuid)).await;
 
     let channel: Channel;
 
-    if let Ok(cache_hit) = cache_result {
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
         channel = serde_json::from_str(&cache_hit).unwrap();
 
-        let result = data.del_cache_key(format!("{}", channel_uuid)).await;
+        data.del_cache_key(format!("{}", channel_uuid)).await?;
-
-        if let Err(error) = result {
-            error!("{}", error)
-        }
     } else {
-        let channel_result = Channel::fetch_one(&data.pool, guild_uuid, channel_uuid).await;
+        channel = Channel::fetch_one(&mut conn, channel_uuid).await?;
-
-        if let Err(error) = channel_result {
-            return Ok(error);
-        }
-
-        channel = channel_result.unwrap();
     }
 
-    let delete_result = channel.delete(&data.pool).await;
+    channel.delete(&mut conn).await?;
-
-    if let Err(error) = delete_result {
-        return Ok(error);
-    }
 
     Ok(HttpResponse::Ok().finish())
 }

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

@@ -1,7 +1,6 @@
 use actix_web::{Error, HttpRequest, HttpResponse, get, rt, web};
 use actix_ws::AggregatedMessage;
 use futures_util::StreamExt as _;
-use log::error;
 use uuid::Uuid;
 
 use crate::{
@@ -22,57 +21,30 @@ pub async fn echo(
     let headers = req.headers();
 
     // Retrieve auth header
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     // Get uuids from path
     let (guild_uuid, channel_uuid) = path.into_inner();
 
+    let mut conn = data.pool.get().await.map_err(|e| crate::error::Error::from(e))?;
+
     // Authorize client using auth header
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    if let Err(error) = authorized {
-        return Ok(error);
-    }
-
-    // Unwrap user uuid from authorization
-    let uuid = authorized.unwrap();
 
     // Get server member from psql
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
-
-    // Get cache for channel
-    let cache_result = data.get_cache_key(format!("{}", channel_uuid)).await;
 
     let channel: Channel;
 
     // Return channel cache or result from psql as `channel` variable
-    if let Ok(cache_hit) = cache_result {
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
         channel = serde_json::from_str(&cache_hit).unwrap()
     } else {
-        let channel_result = Channel::fetch_one(&data.pool, guild_uuid, channel_uuid).await;
+        channel = Channel::fetch_one(&mut conn, channel_uuid).await?;
 
-        if let Err(error) = channel_result {
+        data
-            return Ok(error);
-        }
-
-        channel = channel_result.unwrap();
-
-        let cache_result = data
             .set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
-            .await;
+            .await?;
-
-        if let Err(error) = cache_result {
-            error!("{}", error);
-            return Ok(HttpResponse::InternalServerError().finish());
-        }
     }
 
     let (res, mut session_1, stream) = actix_ws::handle(&req, stream)?;
@@ -82,17 +54,11 @@ pub async fn echo(
         // aggregate continuation frames up to 1MiB
         .max_continuation_size(2_usize.pow(20));
 
-    let pubsub_result = data.cache_pool.get_async_pubsub().await;
+    let mut pubsub = data.cache_pool.get_async_pubsub().await.map_err(|e| crate::error::Error::from(e))?;
-
-    if let Err(error) = pubsub_result {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
 
     let mut session_2 = session_1.clone();
 
     rt::spawn(async move {
-        let mut pubsub = pubsub_result.unwrap();
         pubsub.subscribe(channel_uuid.to_string()).await.unwrap();
         while let Some(msg) = pubsub.on_message().next().await {
             let payload: String = msg.get_payload().unwrap();
@@ -118,7 +84,7 @@ pub async fn echo(
                         .await
                         .unwrap();
                     channel
-                        .new_message(&data.pool, uuid, text.to_string())
+                        .new_message(&mut data.pool.get().await.unwrap(), uuid, text.to_string())
                         .await
                         .unwrap();
                 }

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

@@ -1,8 +1,9 @@
-use actix_web::{Error, HttpRequest, HttpResponse, get, post, web};
+use actix_web::{HttpRequest, HttpResponse, get, post, web};
 use serde::Deserialize;
 use uuid::Uuid;
 
 use crate::{
+    error::Error,
     Data,
     api::v1::auth::check_access_token,
     structs::{Guild, Member},
@@ -22,43 +23,21 @@ pub async fn get(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let guild_uuid = path.into_inner().0;
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
+    let guild = Guild::fetch_one(&mut conn, guild_uuid).await?;
 
-    if let Err(error) = member {
+    let invites = guild.get_invites(&mut conn).await?;
-        return Ok(error);
-    }
 
-    let guild_result = Guild::fetch_one(&data.pool, guild_uuid).await;
+    Ok(HttpResponse::Ok().json(invites))
-
-    if let Err(error) = guild_result {
-        return Ok(error);
-    }
-
-    let guild = guild_result.unwrap();
-
-    let invites = guild.get_invites(&data.pool).await;
-
-    if let Err(error) = invites {
-        return Ok(error);
-    }
-
-    Ok(HttpResponse::Ok().json(invites.unwrap()))
 }
 
 #[post("{uuid}/invites")]
@@ -70,45 +49,21 @@ pub async fn create(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let guild_uuid = path.into_inner().0;
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    let member = Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
-    let member_result = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
+    let guild = Guild::fetch_one(&mut conn, guild_uuid).await?;
-
-    if let Err(error) = member_result {
-        return Ok(error);
-    }
-
-    let member = member_result.unwrap();
-
-    let guild_result = Guild::fetch_one(&data.pool, guild_uuid).await;
-
-    if let Err(error) = guild_result {
-        return Ok(error);
-    }
-
-    let guild = guild_result.unwrap();
 
     let custom_id = invite_request.as_ref().map(|ir| ir.custom_id.clone());
 
-    let invite = guild.create_invite(&data.pool, &member, custom_id).await;
+    let invite = guild.create_invite(&mut conn, &member, custom_id).await?;
 
-    if let Err(error) = invite {
+    Ok(HttpResponse::Ok().json(invite))
-        return Ok(error);
-    }
-
-    Ok(HttpResponse::Ok().json(invite.unwrap()))
 }

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

@@ -1,4 +1,4 @@
-use actix_web::{Error, HttpRequest, HttpResponse, Scope, get, web};
+use actix_web::{HttpRequest, HttpResponse, Scope, get, web};
 use uuid::Uuid;
 
 mod channels;
@@ -6,6 +6,7 @@ mod invites;
 mod roles;
 
 use crate::{
+    error::Error,
     Data,
     api::v1::auth::check_access_token,
     structs::{Guild, Member},
@@ -40,33 +41,17 @@ pub async fn res(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let guild_uuid = path.into_inner().0;
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
+    let guild = Guild::fetch_one(&mut conn, guild_uuid).await?;
 
-    if let Err(error) = member {
+    Ok(HttpResponse::Ok().json(guild))
-        return Ok(error);
-    }
-
-    let guild = Guild::fetch_one(&data.pool, guild_uuid).await;
-
-    if let Err(error) = guild {
-        return Ok(error);
-    }
-
-    Ok(HttpResponse::Ok().json(guild.unwrap()))
 }

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

@@ -1,13 +1,14 @@
+use ::uuid::Uuid;
+use actix_web::{HttpRequest, HttpResponse, get, post, web};
+use serde::Deserialize;
+
 use crate::{
+    error::Error,
     Data,
     api::v1::auth::check_access_token,
     structs::{Member, Role},
     utils::get_auth_header,
 };
-use ::uuid::Uuid;
-use actix_web::{Error, HttpRequest, HttpResponse, get, post, web};
-use log::error;
-use serde::Deserialize;
 
 pub mod uuid;
 
@@ -24,52 +25,27 @@ pub async fn get(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let guild_uuid = path.into_inner().0;
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}_roles", guild_uuid)).await {
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
-
-    let cache_result = data.get_cache_key(format!("{}_roles", guild_uuid)).await;
-
-    if let Ok(cache_hit) = cache_result {
         return Ok(HttpResponse::Ok()
             .content_type("application/json")
             .body(cache_hit));
     }
 
-    let roles_result = Role::fetch_all(&data.pool, guild_uuid).await;
+    let roles = Role::fetch_all(&mut conn, guild_uuid).await?;
 
-    if let Err(error) = roles_result {
+    data
-        return Ok(error);
-    }
-
-    let roles = roles_result.unwrap();
-
-    let cache_result = data
         .set_cache_key(format!("{}_roles", guild_uuid), roles.clone(), 1800)
-        .await;
+        .await?;
-
-    if let Err(error) = cache_result {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
 
     Ok(HttpResponse::Ok().json(roles))
 }
@@ -83,35 +59,19 @@ pub async fn create(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let guild_uuid = path.into_inner().0;
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await.unwrap();
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
-
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
 
     // FIXME: Logic to check permissions, should probably be done in utils.rs
 
-    let role = Role::new(&data.pool, guild_uuid, role_info.name.clone()).await;
+    let role = Role::new(&mut conn, guild_uuid, role_info.name.clone()).await?;
 
-    if let Err(error) = role {
+    Ok(HttpResponse::Ok().json(role))
-        return Ok(error);
-    }
-
-    Ok(HttpResponse::Ok().json(role.unwrap()))
 }

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

@@ -1,12 +1,12 @@
 use crate::{
+    error::Error,
     Data,
     api::v1::auth::check_access_token,
     structs::{Member, Role},
     utils::get_auth_header,
 };
 use ::uuid::Uuid;
-use actix_web::{Error, HttpRequest, HttpResponse, get, web};
+use actix_web::{HttpRequest, HttpResponse, get, web};
-use log::error;
 
 #[get("{uuid}/roles/{role_uuid}")]
 pub async fn get(
@@ -16,52 +16,27 @@ pub async fn get(
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let auth_header = get_auth_header(headers);
+    let auth_header = get_auth_header(headers)?;
-
-    if let Err(error) = auth_header {
-        return Ok(error);
-    }
 
     let (guild_uuid, role_uuid) = path.into_inner();
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    let uuid = check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let uuid = authorized.unwrap();
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
-    let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}", role_uuid)).await {
-
-    if let Err(error) = member {
-        return Ok(error);
-    }
-
-    let cache_result = data.get_cache_key(format!("{}", role_uuid)).await;
-
-    if let Ok(cache_hit) = cache_result {
         return Ok(HttpResponse::Ok()
             .content_type("application/json")
             .body(cache_hit));
     }
 
-    let role_result = Role::fetch_one(&data.pool, guild_uuid, role_uuid).await;
+    let role = Role::fetch_one(&mut conn, role_uuid).await?;
 
-    if let Err(error) = role_result {
+    data
-        return Ok(error);
-    }
-
-    let role = role_result.unwrap();
-
-    let cache_result = data
         .set_cache_key(format!("{}", role_uuid), role.clone(), 60)
-        .await;
+        .await?;
-
-    if let Err(error) = cache_result {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
 
     Ok(HttpResponse::Ok().json(role))
 }