gorb/backend
4
0
Fork 1
Code Issues 1 Pull requests 1 Projects Releases Packages 1 Wiki Activity Actions

feat: migrate to diesel and new error type in users

Browse source
This commit is contained in:
Radical 2025-05-23 12:56:51 +02:00
parent 6190d76285
commit dfe2ca9486
3 changed files with 59 additions and 88 deletions
Download patch file Download diff file Expand all files Collapse all files

52
src/api/v1/users/me.rs
View file

@ -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 {
return Ok(error);
}
let mut conn = data.pool.get().await?;
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 user: Result<Response, diesel::result::Error> = dsl::users
.filter(dsl::uuid.eq(uuid))
.select(Response::as_select())
.get_result(&mut conn)
.await;
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(Response {
uuid: uuid.to_string(),
username,
display_name: display_name.unwrap_or_default(),
}))
Ok(HttpResponse::Ok().json(user.unwrap()))
}

45
src/api/v1/users/mod.rs
View file

@ -1,15 +1,19 @@
use crate::{api::v1::auth::check_access_token, structs::StartAmountQuery, utils::get_auth_header, Data};
use actix_web::{Error, HttpRequest, HttpResponse, Scope, get, web};
use log::error;
use actix_web::{HttpRequest, HttpResponse, Scope, get, web};
use diesel::{prelude::Queryable, QueryDsl, Selectable, SelectableHelper};
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 {
return Ok(error);
}
check_access_token(auth_header, &mut conn).await?;
let row = sqlx::query_as("SELECT CAST(uuid AS VARCHAR), username, display_name, email FROM users ORDER BY username LIMIT $1 OFFSET $2")
.bind(amount)
.bind(start)
.fetch_all(&data.pool)
.await;
let users: Vec<Response> = dsl::users
.order_by(dsl::username)
.offset(start)
.limit(amount)
.select(Response::as_select())
.load(&mut conn)
.await?;
if let Err(error) = row {
error!("{}", error);
return Ok(HttpResponse::InternalServerError().finish());
}
let accounts: Vec<Response> = row.unwrap();
Ok(HttpResponse::Ok().json(accounts))
Ok(HttpResponse::Ok().json(users))
}

50
src/api/v1/users/uuid.rs
View file

@ -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 {
return Ok(error);
}
let mut conn = data.pool.get().await?;
let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
if let Err(error) = authorized {
return Ok(error);
}
check_access_token(auth_header, &mut conn).await?;
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!(
"SELECT username, display_name FROM users WHERE uuid = '{}'",
uuid
))
.fetch_one(&data.pool)
.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 user: Response = dsl::users
.filter(dsl::uuid.eq(uuid))
.select(Response::as_select())
.get_result(&mut conn)
.await?;
let cache_result = data
.set_cache_key(uuid.to_string(), user.clone(), 1800)