radical/backend-ci-testing
1
0
Fork 0
forked from gorb/backend
Code Pull requests Activity

feat: implement proper user and me structs

Browse source
This commit is contained in:
Radical 2025-05-20 18:04:44 +02:00
parent cee1b41e89
commit b66c8f0613
5 changed files with 191 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,15 +1,7 @@
use actix_web::{Error, HttpRequest, HttpResponse, get, web};
use log::error;
use serde::Serialize;
use actix_web::{get, post, web, Error, HttpRequest, HttpResponse};
use serde::Deserialize;
use crate::{Data, api::v1::auth::check_access_token, utils::get_auth_header};
#[derive(Serialize)]
struct Response {
uuid: String,
username: String,
display_name: String,
}
use crate::{api::v1::auth::check_access_token, structs::Me, utils::get_auth_header, Data};
#[get("/me")]
pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse, Error> {
@ -29,23 +21,64 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
let uuid = authorized.unwrap();
let row = sqlx::query_as(&format!(
"SELECT username, display_name FROM users WHERE uuid = '{}'",
uuid
))
.fetch_one(&data.pool)
.await;
let me = Me::get(&data.pool, uuid).await;
if let Err(error) = row {
error!("{}", error);
return Ok(HttpResponse::InternalServerError().finish());
if let Err(error) = me {
return Ok(error);
}
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(me.unwrap()))
}
#[derive(Deserialize)]
struct NewInfo {
username: Option<String>,
display_name: Option<String>,
password: Option<String>,
email: Option<String>,
}
#[post("/me")]
pub async fn update(req: HttpRequest, new_info: web::Json<NewInfo>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
let headers = req.headers();
let auth_header = get_auth_header(headers);
if let Err(error) = auth_header {
return Ok(error);
}
let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
if let Err(error) = authorized {
return Ok(error);
}
let uuid = authorized.unwrap();
let me_result = Me::get(&data.pool, uuid).await;
if let Err(error) = me_result {
return Ok(error);
}
let me = me_result;
if let Some(username) = &new_info.username {
todo!();
}
if let Some(display_name) = &new_info.display_name {
todo!();
}
if let Some(password) = &new_info.password {
todo!();
}
if let Some(email) = &new_info.email {
todo!();
}
Ok(HttpResponse::Ok().finish())
}

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

@ -1,8 +1,6 @@
use crate::{Data, api::v1::auth::check_access_token, utils::get_auth_header};
use crate::{api::v1::auth::check_access_token, structs::User, utils::get_auth_header, Data};
use actix_web::{Error, HttpRequest, HttpResponse, Scope, get, web};
use log::error;
use serde::{Deserialize, Serialize};
use sqlx::prelude::FromRow;
use serde::Deserialize;
mod me;
mod uuid;
@ -13,14 +11,6 @@ struct RequestQuery {
amount: Option<i32>,
}
#[derive(Serialize, FromRow)]
struct Response {
uuid: String,
username: String,
display_name: Option<String>,
email: String,
}
pub fn web() -> Scope {
web::scope("/users")
.service(res)
@ -52,18 +42,11 @@ pub async fn res(
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")
.bind(amount)
.bind(start)
.fetch_all(&data.pool)
.await;
let accounts = User::fetch_all(&data.pool, start, amount).await;
if let Err(error) = row {
error!("{}", error);
return Ok(HttpResponse::InternalServerError().finish());
if let Err(error) = accounts {
return Ok(error);
}
let accounts: Vec<Response> = row.unwrap();
Ok(HttpResponse::Ok().json(accounts))
Ok(HttpResponse::Ok().json(accounts.unwrap()))
}

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

@ -1,16 +1,8 @@
use actix_web::{Error, HttpRequest, HttpResponse, get, web};
use log::error;
use serde::Serialize;
use uuid::Uuid;
use crate::{Data, api::v1::auth::check_access_token, utils::get_auth_header};
#[derive(Serialize, Clone)]
struct Response {
uuid: String,
username: String,
display_name: String,
}
use crate::{api::v1::auth::check_access_token, structs::User, utils::get_auth_header, Data};
#[get("/{uuid}")]
pub async fn res(
@ -42,25 +34,13 @@ 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;
let user_result = User::fetch_one(&data.pool, uuid).await;
if let Err(error) = row {
error!("{}", error);
return Ok(HttpResponse::InternalServerError().finish());
if let Err(error) = user_result {
return Ok(error);
}
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 = user_result.unwrap();
let cache_result = data
.set_cache_key(uuid.to_string(), user.clone(), 1800)

1
src/main.rs
View file

@ -68,6 +68,7 @@ async fn main() -> Result<(), Error> {
password varchar(512) NOT NULL,
email varchar(100) NOT NULL,
email_verified boolean NOT NULL DEFAULT FALSE,
avatar varchar(100) DEFAULT NULL,
is_deleted boolean NOT NULL DEFAULT FALSE,
deleted_at int8 DEFAULT NULL,
CONSTRAINT unique_username_active UNIQUE NULLS NOT DISTINCT (username, is_deleted),

120
src/structs.rs
View file

@ -740,7 +740,7 @@ pub struct Message {
}
#[derive(FromRow)]
pub struct InviteBuilder {
struct InviteBuilder {
id: String,
user_uuid: String,
guild_uuid: String,
@ -784,3 +784,121 @@ impl Invite {
Ok(invite.unwrap().build())
}
}
#[derive(FromRow, Clone)]
struct UserBuilder {
uuid: String,
username: String,
display_name: Option<String>,
avatar: Option<String>,
email: Option<String>,
}
impl UserBuilder {
fn build(self) -> User {
User {
uuid: Uuid::from_str(&self.uuid).unwrap(),
username: self.username,
display_name: self.display_name,
avatar: self.avatar,
email: self.email,
}
}
}
#[derive(Serialize, Clone)]
pub struct User {
uuid: Uuid,
username: String,
display_name: Option<String>,
avatar: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
email: Option<String>,
}
impl User {
pub async fn fetch_one(pool: &Pool<Postgres>, user_uuid: Uuid) -> Result<Self, HttpResponse> {
let user_result: Result<UserBuilder, sqlx::Error> =
sqlx::query_as(&format!("SELECT CAST(uuid AS VARCHAR), username, display_name, avatar, email FROM users WHERE uuid = '{}'", user_uuid))
.fetch_one(pool)
.await;
if let Err(error) = user_result {
error!("{}", error);
return Err(HttpResponse::InternalServerError().finish());
}
let mut user = user_result.unwrap();
// Override email since it shouldn't be returned by this (FromRow impl kinda sucks since it doesnt automatically count missing columns as Nulls)
user.email = None;
Ok(user.build())
}
pub async fn fetch_all(pool: &Pool<Postgres>, start: i32, amount: i32) -> Result<Vec<Self>, HttpResponse> {
let row = sqlx::query_as("SELECT CAST(uuid AS VARCHAR), username, display_name, avatar, email FROM users ORDER BY username LIMIT $1 OFFSET $2")
.bind(amount)
.bind(start)
.fetch_all(pool)
.await;
if let Err(error) = row {
error!("{}", error);
return Err(HttpResponse::InternalServerError().finish());
}
let accounts: Vec<UserBuilder> = row.unwrap();
Ok(accounts.iter().map(|u| u.clone().build()).collect())
}
}
#[derive(FromRow)]
struct MeBuilder {
uuid: String,
username: String,
display_name: Option<String>,
avatar: Option<String>,
email: String,
email_verified: bool,
}
impl MeBuilder {
fn build(self) -> Me {
Me {
uuid: Uuid::from_str(&self.uuid).unwrap(),
username: self.username,
display_name: self.display_name,
avatar: self.avatar,
email: self.email,
email_verified: self.email_verified,
}
}
}
#[derive(Serialize)]
pub struct Me {
uuid: Uuid,
username: String,
display_name: Option<String>,
avatar: Option<String>,
email: String,
email_verified: bool,
}
impl Me {
pub async fn get(pool: &Pool<Postgres>, user_uuid: Uuid) -> Result<Self, HttpResponse> {
let me: Result<MeBuilder, sqlx::Error> = sqlx::query_as(&format!("SELECT CAST(uuid AS VARCHAR), username, display_name, avatar, email, email_verified FROM users WHERE uuid = '{}'", user_uuid))
.fetch_one(pool)
.await;
if let Err(error) = me {
error!("{}", error);
return Err(HttpResponse::InternalServerError().finish())
}
Ok(me.unwrap().build())
}
}