src/api/v1/users/me.rs

@@ -1,51 +1,41 @@
-use actix_web::{Error, HttpRequest, HttpResponse, get, web};
+use actix_web::{HttpRequest, HttpResponse, get, web};
+use diesel::{prelude::Queryable, ExpressionMethods, QueryDsl, Selectable, SelectableHelper};
+use diesel_async::RunQueryDsl;
 use log::error;
 use serde::Serialize;
+use uuid::Uuid;
 
-use crate::{Data, api::v1::auth::check_access_token, utils::get_auth_header};
+use crate::{error::Error, api::v1::auth::check_access_token, schema::users::{self, dsl}, utils::get_auth_header, Data};
 
-#[derive(Serialize)]
+#[derive(Serialize, Queryable, Selectable)]
+#[diesel(table_name = users)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
 struct Response {
-    uuid: String,
+    uuid: Uuid,
     username: String,
-    display_name: String,
+    display_name: Option<String>,
 }
 
 #[get("/me")]
 pub async fn res(req: HttpRequest, data: web::Data<Data>) -> 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 {
+    let user: Result<Response, diesel::result::Error> = dsl::users
-        return Ok(error);
+        .filter(dsl::uuid.eq(uuid))
-    }
+        .select(Response::as_select())
-
+        .get_result(&mut conn)
-    let uuid = authorized.unwrap();
-
-    let row = sqlx::query_as(&format!(
-        "SELECT username, display_name FROM users WHERE uuid = '{}'",
-        uuid
-    ))
-    .fetch_one(&data.pool)
         .await;
 
-    if let Err(error) = row {
+    if let Err(error) = user {
         error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
+        return Ok(HttpResponse::InternalServerError().finish())
     }
 
-    let (username, display_name): (String, Option<String>) = row.unwrap();
+    Ok(HttpResponse::Ok().json(user.unwrap()))
-
-    Ok(HttpResponse::Ok().json(Response {
-        uuid: uuid.to_string(),
-        username,
-        display_name: display_name.unwrap_or_default(),
-    }))
 }

src/api/v1/users/mod.rs

@@ -1,15 +1,19 @@
-use crate::{api::v1::auth::check_access_token, structs::StartAmountQuery, utils::get_auth_header, Data};
+use actix_web::{HttpRequest, HttpResponse, Scope, get, web};
-use actix_web::{Error, HttpRequest, HttpResponse, Scope, get, web};
+use diesel::{prelude::Queryable, QueryDsl, Selectable, SelectableHelper};
-use log::error;
+use diesel_async::RunQueryDsl;
 use serde::Serialize;
-use sqlx::prelude::FromRow;
+use ::uuid::Uuid;
+
+use crate::{error::Error,api::v1::auth::check_access_token, schema::users::{self, dsl}, structs::StartAmountQuery, utils::get_auth_header, Data};
 
 mod me;
 mod uuid;
 
-#[derive(Serialize, FromRow)]
+#[derive(Serialize, Queryable, Selectable)]
+#[diesel(table_name = users)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
 struct Response {
-    uuid: String,
+    uuid: Uuid,
     username: String,
     display_name: Option<String>,
     email: String,
@@ -30,7 +34,7 @@ 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)?;
 
     let start = request_query.start.unwrap_or(0);
 
@@ -40,24 +44,17 @@ pub async fn res(
         return Ok(HttpResponse::BadRequest().finish());
     }
 
-    let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
+    let mut conn = data.pool.get().await?;
 
-    if let Err(error) = authorized {
+    check_access_token(auth_header, &mut conn).await?;
-        return Ok(error);
-    }
 
-    let row = sqlx::query_as("SELECT CAST(uuid AS VARCHAR), username, display_name, email FROM users ORDER BY username LIMIT $1 OFFSET $2")
+    let users: Vec<Response> = dsl::users
-        .bind(amount)
+        .order_by(dsl::username)
-        .bind(start)
+        .offset(start)
-        .fetch_all(&data.pool)
+        .limit(amount)
-        .await;
+        .select(Response::as_select())
+        .load(&mut conn)
+        .await?;
 
-    if let Err(error) = row {
+    Ok(HttpResponse::Ok().json(users))
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
-
-    let accounts: Vec<Response> = row.unwrap();
-
-    Ok(HttpResponse::Ok().json(accounts))
 }

src/api/v1/users/uuid.rs

@@ -1,15 +1,19 @@
-use actix_web::{Error, HttpRequest, HttpResponse, get, web};
+use actix_web::{HttpRequest, HttpResponse, get, web};
+use diesel::{ExpressionMethods, QueryDsl, Queryable, Selectable, SelectableHelper};
+use diesel_async::RunQueryDsl;
 use log::error;
 use serde::Serialize;
 use uuid::Uuid;
 
-use crate::{Data, api::v1::auth::check_access_token, utils::get_auth_header};
+use crate::{error::Error, api::v1::auth::check_access_token, schema::users::{self, dsl}, utils::get_auth_header, Data};
 
-#[derive(Serialize, Clone)]
+#[derive(Serialize, Queryable, Selectable, Clone)]
+#[diesel(table_name = users)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
 struct Response {
-    uuid: String,
+    uuid: Uuid,
     username: String,
-    display_name: String,
+    display_name: Option<String>,
 }
 
 #[get("/{uuid}")]
@@ -22,17 +26,11 @@ pub async fn res(
 
     let uuid = path.into_inner().0;
 
-    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;
+    check_access_token(auth_header, &mut conn).await?;
-
-    if let Err(error) = authorized {
-        return Ok(error);
-    }
 
     let cache_result = data.get_cache_key(uuid.to_string()).await;
 
@@ -42,25 +40,11 @@ pub async fn res(
             .body(cache_hit));
     }
 
-    let row = sqlx::query_as(&format!(
+    let user: Response = dsl::users
-        "SELECT username, display_name FROM users WHERE uuid = '{}'",
+        .filter(dsl::uuid.eq(uuid))
-        uuid
+        .select(Response::as_select())
-    ))
+        .get_result(&mut conn)
-    .fetch_one(&data.pool)
+        .await?;
-    .await;
-
-    if let Err(error) = row {
-        error!("{}", error);
-        return Ok(HttpResponse::InternalServerError().finish());
-    }
-
-    let (username, display_name): (String, Option<String>) = row.unwrap();
-
-    let user = Response {
-        uuid: uuid.to_string(),
-        username,
-        display_name: display_name.unwrap_or_default(),
-    };
 
     let cache_result = data
         .set_cache_key(uuid.to_string(), user.clone(), 1800)