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

Merge branch 'main' into wip/images

Browse source
This commit is contained in:
Radical 2025-05-23 13:45:17 +02:00
commit 149b81973d
54 changed files with 1201 additions and 1691 deletions
Download patch file Download diff file Expand all files Collapse all files

152
src/api/v1/auth/login.rs
View file

@ -1,14 +1,14 @@
use std::time::{SystemTime, UNIX_EPOCH};
use actix_web::{Error, HttpResponse, post, web};
use actix_web::{HttpResponse, post, web};
use argon2::{PasswordHash, PasswordVerifier};
use log::error;
use diesel::{dsl::insert_into, ExpressionMethods, QueryDsl};
use diesel_async::RunQueryDsl;
use serde::Deserialize;
use uuid::Uuid;
use crate::{
Data,
api::v1::auth::{EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX},
utils::{generate_access_token, generate_refresh_token, refresh_token_cookie},
error::Error, api::v1::auth::{EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX}, schema::*, utils::{generate_access_token, generate_refresh_token, refresh_token_cookie}, Data
};
use super::Response;
@ -29,66 +29,42 @@ pub async fn response(
return Ok(HttpResponse::Forbidden().json(r#"{ "password_hashed": false }"#));
}
use users::dsl;
let mut conn = data.pool.get().await?;
if EMAIL_REGEX.is_match(&login_information.username) {
let row =
sqlx::query_as("SELECT CAST(uuid as VARCHAR), password FROM users WHERE email = $1")
.bind(&login_information.username)
.fetch_one(&data.pool)
.await;
// FIXME: error handling, right now i just want this to work
let (uuid, password): (Uuid, String) = dsl::users
.filter(dsl::email.eq(&login_information.username))
.select((dsl::uuid, dsl::password))
.get_result(&mut conn)
.await?;
if let Err(error) = row {
if error.to_string()
== "no rows returned by a query that expected to return at least one row"
{
return Ok(HttpResponse::Unauthorized().finish());
}
error!("{}", error);
return Ok(HttpResponse::InternalServerError().json(
r#"{ "error": "Unhandled exception occured, contact the server administrator" }"#,
));
}
let (uuid, password): (String, String) = row.unwrap();
return Ok(login(
return login(
data.clone(),
uuid,
login_information.password.clone(),
password,
login_information.device_name.clone(),
)
.await);
.await;
} else if USERNAME_REGEX.is_match(&login_information.username) {
let row =
sqlx::query_as("SELECT CAST(uuid as VARCHAR), password FROM users WHERE username = $1")
.bind(&login_information.username)
.fetch_one(&data.pool)
.await;
// FIXME: error handling, right now i just want this to work
let (uuid, password): (Uuid, String) = dsl::users
.filter(dsl::username.eq(&login_information.username))
.select((dsl::uuid, dsl::password))
.get_result(&mut conn)
.await?;
if let Err(error) = row {
if error.to_string()
== "no rows returned by a query that expected to return at least one row"
{
return Ok(HttpResponse::Unauthorized().finish());
}
error!("{}", error);
return Ok(HttpResponse::InternalServerError().json(
r#"{ "error": "Unhandled exception occured, contact the server administrator" }"#,
));
}
let (uuid, password): (String, String) = row.unwrap();
return Ok(login(
return login(
data.clone(),
uuid,
login_information.password.clone(),
password,
login_information.device_name.clone(),
)
.await);
.await;
}
Ok(HttpResponse::Unauthorized().finish())
@ -96,79 +72,45 @@ pub async fn response(
async fn login(
data: actix_web::web::Data<Data>,
uuid: String,
uuid: Uuid,
request_password: String,
database_password: String,
device_name: String,
) -> HttpResponse {
let parsed_hash_raw = PasswordHash::new(&database_password);
) -> Result<HttpResponse, Error> {
let mut conn = data.pool.get().await?;
if let Err(error) = parsed_hash_raw {
error!("{}", error);
return HttpResponse::InternalServerError().finish();
}
let parsed_hash = parsed_hash_raw.unwrap();
let parsed_hash = PasswordHash::new(&database_password).map_err(|e| Error::PasswordHashError(e.to_string()))?;
if data
.argon2
.verify_password(request_password.as_bytes(), &parsed_hash)
.is_err()
{
return HttpResponse::Unauthorized().finish();
return Err(Error::Unauthorized("Wrong username or password".to_string()));
}
let refresh_token_raw = generate_refresh_token();
let access_token_raw = generate_access_token();
if let Err(error) = refresh_token_raw {
error!("{}", error);
return HttpResponse::InternalServerError().finish();
}
let refresh_token = refresh_token_raw.unwrap();
if let Err(error) = access_token_raw {
error!("{}", error);
return HttpResponse::InternalServerError().finish();
}
let access_token = access_token_raw.unwrap();
let refresh_token = generate_refresh_token()?;
let access_token = generate_access_token()?;
let current_time = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.duration_since(UNIX_EPOCH)?
.as_secs() as i64;
if let Err(error) = sqlx::query(&format!(
"INSERT INTO refresh_tokens (token, uuid, created_at, device_name) VALUES ($1, '{}', $2, $3 )",
uuid
))
.bind(&refresh_token)
.bind(current_time)
.bind(device_name)
.execute(&data.pool)
.await
{
error!("{}", error);
return HttpResponse::InternalServerError().finish();
}
use refresh_tokens::dsl as rdsl;
if let Err(error) = sqlx::query(&format!(
"INSERT INTO access_tokens (token, refresh_token, uuid, created_at) VALUES ($1, $2, '{}', $3 )",
uuid
))
.bind(&access_token)
.bind(&refresh_token)
.bind(current_time)
.execute(&data.pool)
.await
{
error!("{}", error);
return HttpResponse::InternalServerError().finish()
}
insert_into(refresh_tokens::table)
.values((rdsl::token.eq(&refresh_token), rdsl::uuid.eq(uuid), rdsl::created_at.eq(current_time), rdsl::device_name.eq(device_name)))
.execute(&mut conn)
.await?;
HttpResponse::Ok()
use access_tokens::dsl as adsl;
insert_into(access_tokens::table)
.values((adsl::token.eq(&access_token), adsl::refresh_token.eq(&refresh_token), adsl::uuid.eq(uuid), adsl::created_at.eq(current_time)))
.execute(&mut conn)
.await?;
Ok(HttpResponse::Ok()
.cookie(refresh_token_cookie(refresh_token))
.json(Response { access_token })
.json(Response { access_token }))
}

53
src/api/v1/auth/mod.rs
View file

@ -1,16 +1,17 @@
use std::{
str::FromStr,
sync::LazyLock,
time::{SystemTime, UNIX_EPOCH},
};
use actix_web::{HttpResponse, Scope, web};
use log::error;
use actix_web::{Scope, web};
use diesel::{ExpressionMethods, QueryDsl};
use diesel_async::RunQueryDsl;
use regex::Regex;
use serde::Serialize;
use sqlx::Postgres;
use uuid::Uuid;
use crate::{error::Error, Conn, schema::access_tokens::dsl};
mod login;
mod refresh;
mod register;
@ -40,40 +41,30 @@ pub fn web() -> Scope {
pub async fn check_access_token(
access_token: &str,
pool: &sqlx::Pool<Postgres>,
) -> Result<Uuid, HttpResponse> {
let row = sqlx::query_as(
"SELECT CAST(uuid as VARCHAR), created_at FROM access_tokens WHERE token = $1",
)
.bind(access_token)
.fetch_one(pool)
.await;
if let Err(error) = row {
if error.to_string()
== "no rows returned by a query that expected to return at least one row"
{
return Err(HttpResponse::Unauthorized().finish());
}
error!("{}", error);
return Err(HttpResponse::InternalServerError().json(
r#"{ "error": "Unhandled exception occured, contact the server administrator" }"#,
));
}
let (uuid, created_at): (String, i64) = row.unwrap();
conn: &mut Conn,
) -> Result<Uuid, Error> {
let (uuid, created_at): (Uuid, i64) = dsl::access_tokens
.filter(dsl::token.eq(access_token))
.select((dsl::uuid, dsl::created_at))
.get_result(conn)
.await
.map_err(|error| {
if error == diesel::result::Error::NotFound {
Error::Unauthorized("Invalid access token".to_string())
} else {
Error::from(error)
}
})?;
let current_time = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.duration_since(UNIX_EPOCH)?
.as_secs() as i64;
let lifetime = current_time - created_at;
if lifetime > 3600 {
return Err(HttpResponse::Unauthorized().finish());
return Err(Error::Unauthorized("Invalid access token".to_string()));
}
Ok(Uuid::from_str(&uuid).unwrap())
Ok(uuid)
}

75
src/api/v1/auth/refresh.rs
View file

@ -1,10 +1,11 @@
use actix_web::{Error, HttpRequest, HttpResponse, post, web};
use actix_web::{HttpRequest, HttpResponse, post, web};
use diesel::{delete, update, ExpressionMethods, QueryDsl};
use diesel_async::RunQueryDsl;
use log::error;
use std::time::{SystemTime, UNIX_EPOCH};
use crate::{
Data,
utils::{generate_access_token, generate_refresh_token, refresh_token_cookie},
error::Error, schema::{access_tokens::{self, dsl}, refresh_tokens::{self, dsl as rdsl}}, utils::{generate_access_token, generate_refresh_token, refresh_token_cookie}, Data
};
use super::Response;
@ -20,23 +21,23 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
let mut refresh_token = String::from(recv_refresh_token_cookie.unwrap().value());
let current_time = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.duration_since(UNIX_EPOCH)?
.as_secs() as i64;
if let Ok(row) = sqlx::query_scalar("SELECT created_at FROM refresh_tokens WHERE token = $1")
.bind(&refresh_token)
.fetch_one(&data.pool)
let mut conn = data.pool.get().await?;
if let Ok(created_at) = rdsl::refresh_tokens
.filter(rdsl::token.eq(&refresh_token))
.select(rdsl::created_at)
.get_result::<i64>(&mut conn)
.await
{
let created_at: i64 = row;
let lifetime = current_time - created_at;
if lifetime > 2592000 {
if let Err(error) = sqlx::query("DELETE FROM refresh_tokens WHERE token = $1")
.bind(&refresh_token)
.execute(&data.pool)
if let Err(error) = delete(refresh_tokens::table)
.filter(rdsl::token.eq(&refresh_token))
.execute(&mut conn)
.await
{
error!("{}", error);
@ -52,8 +53,7 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
}
let current_time = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.duration_since(UNIX_EPOCH)?
.as_secs() as i64;
if lifetime > 1987200 {
@ -66,14 +66,14 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
let new_refresh_token = new_refresh_token.unwrap();
match sqlx::query(
"UPDATE refresh_tokens SET token = $1, created_at = $2 WHERE token = $3",
)
.bind(&new_refresh_token)
.bind(current_time)
.bind(&refresh_token)
.execute(&data.pool)
.await
match update(refresh_tokens::table)
.filter(rdsl::token.eq(&refresh_token))
.set((
rdsl::token.eq(&new_refresh_token),
rdsl::created_at.eq(current_time),
))
.execute(&mut conn)
.await
{
Ok(_) => {
refresh_token = new_refresh_token;
@ -84,27 +84,16 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
}
}
let access_token = generate_access_token();
let access_token = generate_access_token()?;
if access_token.is_err() {
error!("{}", access_token.unwrap_err());
return Ok(HttpResponse::InternalServerError().finish());
}
let access_token = access_token.unwrap();
if let Err(error) = sqlx::query(
"UPDATE access_tokens SET token = $1, created_at = $2 WHERE refresh_token = $3",
)
.bind(&access_token)
.bind(current_time)
.bind(&refresh_token)
.execute(&data.pool)
.await
{
error!("{}", error);
return Ok(HttpResponse::InternalServerError().finish());
}
update(access_tokens::table)
.filter(dsl::refresh_token.eq(&refresh_token))
.set((
dsl::token.eq(&access_token),
dsl::created_at.eq(current_time),
))
.execute(&mut conn)
.await?;
return Ok(HttpResponse::Ok()
.cookie(refresh_token_cookie(refresh_token))

123
src/api/v1/auth/register.rs
View file

@ -1,19 +1,18 @@
use std::time::{SystemTime, UNIX_EPOCH};
use actix_web::{Error, HttpResponse, post, web};
use actix_web::{HttpResponse, post, web};
use argon2::{
PasswordHasher,
password_hash::{SaltString, rand_core::OsRng},
};
use log::error;
use diesel::{dsl::insert_into, ExpressionMethods};
use diesel_async::RunQueryDsl;
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use super::Response;
use crate::{
Data,
api::v1::auth::{EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX},
utils::{generate_access_token, generate_refresh_token, refresh_token_cookie},
api::v1::auth::{EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX}, error::Error, schema::{access_tokens::{self, dsl as adsl}, refresh_tokens::{self, dsl as rdsl}, users::{self, dsl as udsl}}, utils::{generate_access_token, generate_refresh_token, refresh_token_cookie}, Data
};
#[derive(Deserialize)]
@ -92,91 +91,49 @@ pub async fn res(
.argon2
.hash_password(account_information.password.as_bytes(), &salt)
{
let mut conn = data.pool.get().await?;
// TODO: Check security of this implementation
return Ok(
match sqlx::query(&format!(
"INSERT INTO users (uuid, username, password, email) VALUES ( '{}', $1, $2, $3 )",
uuid
insert_into(users::table)
.values((
udsl::uuid.eq(uuid),
udsl::username.eq(&account_information.identifier),
udsl::password.eq(hashed_password.to_string()),
udsl::email.eq(&account_information.email),
))
.bind(&account_information.identifier)
.bind(hashed_password.to_string())
.bind(&account_information.email)
.execute(&data.pool)
.await
{
Ok(_out) => {
let refresh_token = generate_refresh_token();
let access_token = generate_access_token();
.execute(&mut conn)
.await?;
if refresh_token.is_err() {
error!("{}", refresh_token.unwrap_err());
return Ok(HttpResponse::InternalServerError().finish());
}
let refresh_token = generate_refresh_token()?;
let access_token = generate_access_token()?;
let refresh_token = refresh_token.unwrap();
let current_time = SystemTime::now()
.duration_since(UNIX_EPOCH)?
.as_secs() as i64;
if access_token.is_err() {
error!("{}", access_token.unwrap_err());
return Ok(HttpResponse::InternalServerError().finish());
}
insert_into(refresh_tokens::table)
.values((
rdsl::token.eq(&refresh_token),
rdsl::uuid.eq(uuid),
rdsl::created_at.eq(current_time),
rdsl::device_name.eq(&account_information.device_name),
))
.execute(&mut conn)
.await?;
let access_token = access_token.unwrap();
insert_into(access_tokens::table)
.values((
adsl::token.eq(&access_token),
adsl::refresh_token.eq(&refresh_token),
adsl::uuid.eq(uuid),
adsl::created_at.eq(current_time),
))
.execute(&mut conn)
.await?;
let current_time = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs() as i64;
if let Err(error) = sqlx::query(&format!("INSERT INTO refresh_tokens (token, uuid, created_at, device_name) VALUES ($1, '{}', $2, $3 )", uuid))
.bind(&refresh_token)
.bind(current_time)
.bind(&account_information.device_name)
.execute(&data.pool)
.await {
error!("{}", error);
return Ok(HttpResponse::InternalServerError().finish())
}
if let Err(error) = sqlx::query(&format!("INSERT INTO access_tokens (token, refresh_token, uuid, created_at) VALUES ($1, $2, '{}', $3 )", uuid))
.bind(&access_token)
.bind(&refresh_token)
.bind(current_time)
.execute(&data.pool)
.await {
error!("{}", error);
return Ok(HttpResponse::InternalServerError().finish())
}
HttpResponse::Ok()
.cookie(refresh_token_cookie(refresh_token))
.json(Response { access_token })
}
Err(error) => {
let err_msg = error.as_database_error().unwrap().message();
match err_msg {
err_msg
if err_msg.contains("unique") && err_msg.contains("username_key") =>
{
HttpResponse::Forbidden().json(ResponseError {
gorb_id_available: false,
..Default::default()
})
}
err_msg if err_msg.contains("unique") && err_msg.contains("email_key") => {
HttpResponse::Forbidden().json(ResponseError {
email_available: false,
..Default::default()
})
}
_ => {
error!("{}", err_msg);
HttpResponse::InternalServerError().finish()
}
}
}
},
);
return Ok(HttpResponse::Ok()
.cookie(refresh_token_cookie(refresh_token))
.json(Response { access_token }))
}
Ok(HttpResponse::InternalServerError().finish())

105
src/api/v1/auth/revoke.rs
View file

@ -1,10 +1,10 @@
use actix_web::{Error, HttpRequest, HttpResponse, post, web};
use actix_web::{HttpRequest, HttpResponse, post, web};
use argon2::{PasswordHash, PasswordVerifier};
use futures::future;
use log::error;
use serde::{Deserialize, Serialize};
use diesel::{delete, ExpressionMethods, QueryDsl};
use diesel_async::RunQueryDsl;
use serde::Deserialize;
use crate::{Data, api::v1::auth::check_access_token, utils::get_auth_header};
use crate::{api::v1::auth::check_access_token, error::Error, schema::users::dsl as udsl, schema::refresh_tokens::{self, dsl as rdsl}, utils::get_auth_header, Data};
#[derive(Deserialize)]
struct RevokeRequest {
@ -12,17 +12,6 @@ struct RevokeRequest {
device_name: String,
}
#[derive(Serialize)]
struct Response {
deleted: bool,
}
impl Response {
fn new(deleted: bool) -> Self {
Self { deleted }
}
}
// TODO: Should maybe be a delete request?
#[post("/revoke")]
pub async fn res(
@ -32,85 +21,33 @@ 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 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 database_password: String = udsl::users
.filter(udsl::uuid.eq(uuid))
.select(udsl::password)
.get_result(&mut conn)
.await?;
let uuid = authorized.unwrap();
let database_password_raw = sqlx::query_scalar(&format!(
"SELECT password FROM users WHERE uuid = '{}'",
uuid
))
.fetch_one(&data.pool)
.await;
if let Err(error) = database_password_raw {
error!("{}", error);
return Ok(HttpResponse::InternalServerError().json(Response::new(false)));
}
let database_password: String = database_password_raw.unwrap();
let hashed_password_raw = PasswordHash::new(&database_password);
if let Err(error) = hashed_password_raw {
error!("{}", error);
return Ok(HttpResponse::InternalServerError().json(Response::new(false)));
}
let hashed_password = hashed_password_raw.unwrap();
let hashed_password = PasswordHash::new(&database_password).map_err(|e| Error::PasswordHashError(e.to_string()))?;
if data
.argon2
.verify_password(revoke_request.password.as_bytes(), &hashed_password)
.is_err()
{
return Ok(HttpResponse::Unauthorized().finish());
return Err(Error::Unauthorized("Wrong username or password".to_string()));
}
let tokens_raw = sqlx::query_scalar(&format!(
"SELECT token FROM refresh_tokens WHERE uuid = '{}' AND device_name = $1",
uuid
))
.bind(&revoke_request.device_name)
.fetch_all(&data.pool)
.await;
delete(refresh_tokens::table)
.filter(rdsl::uuid.eq(uuid))
.filter(rdsl::device_name.eq(&revoke_request.device_name))
.execute(&mut conn)
.await?;
if tokens_raw.is_err() {
error!("{:?}", tokens_raw);
return Ok(HttpResponse::InternalServerError().json(Response::new(false)));
}
let tokens: Vec<String> = tokens_raw.unwrap();
let mut refresh_tokens_delete = vec![];
for token in tokens {
refresh_tokens_delete.push(
sqlx::query("DELETE FROM refresh_tokens WHERE token = $1")
.bind(token.clone())
.execute(&data.pool),
);
}
let results = future::join_all(refresh_tokens_delete).await;
let errors: Vec<&Result<sqlx::postgres::PgQueryResult, sqlx::Error>> =
results.iter().filter(|r| r.is_err()).collect();
if !errors.is_empty() {
error!("{:?}", errors);
return Ok(HttpResponse::InternalServerError().finish());
}
Ok(HttpResponse::Ok().json(Response::new(true)))
Ok(HttpResponse::Ok().finish())
}

63
src/api/v1/invites/id.rs
View file

@ -1,6 +1,7 @@
use actix_web::{Error, HttpRequest, HttpResponse, get, post, web};
use actix_web::{HttpRequest, HttpResponse, get, post, web};
use crate::{
error::Error,
Data,
api::v1::auth::check_access_token,
structs::{Guild, Invite, Member},
@ -15,29 +16,17 @@ 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 mut conn = data.pool.get().await?;
check_access_token(auth_header, &mut conn).await?;
let invite_id = path.into_inner().0;
let result = Invite::fetch_one(&data.pool, invite_id).await;
let invite = Invite::fetch_one(&mut conn, invite_id).await?;
if let Err(error) = result {
return Ok(error);
}
let invite = result.unwrap();
let guild_result = Guild::fetch_one(&data.pool, invite.guild_uuid).await;
if let Err(error) = guild_result {
return Ok(error);
}
let guild = guild_result.unwrap();
let guild = Guild::fetch_one(&mut conn, invite.guild_uuid).await?;
Ok(HttpResponse::Ok().json(guild))
}
@ -50,43 +39,19 @@ pub async fn join(
) -> Result<HttpResponse, Error> {
let headers = req.headers();
let auth_header = get_auth_header(headers);
if let Err(error) = auth_header {
return Ok(error);
}
let auth_header = get_auth_header(headers)?;
let invite_id = 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 {
return Ok(error);
}
let uuid = check_access_token(auth_header, &mut conn).await?;
let uuid = authorized.unwrap();
let invite = Invite::fetch_one(&mut conn, invite_id).await?;
let result = Invite::fetch_one(&data.pool, invite_id).await;
let guild = Guild::fetch_one(&mut conn, invite.guild_uuid).await?;
if let Err(error) = result {
return Ok(error);
}
let invite = result.unwrap();
let guild_result = Guild::fetch_one(&data.pool, invite.guild_uuid).await;
if let Err(error) = guild_result {
return Ok(error);
}
let guild = guild_result.unwrap();
let member = Member::new(&data.pool, uuid, guild.uuid).await;
if let Err(error) = member {
return Ok(error);
}
Member::new(&mut conn, uuid, guild.uuid).await?;
Ok(HttpResponse::Ok().json(guild))
}

48
src/api/v1/servers/mod.rs
View file

@ -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 {
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);
}
let uuid = authorized.unwrap();
let uuid = check_access_token(auth_header, &mut conn).await?;
let guild = Guild::new(
&data.pool,
&mut conn,
guild_info.name.clone(),
guild_info.description.clone(),
uuid,
)
.await;
.await?;
if let Err(error) = guild {
return Ok(error);
}
Ok(HttpResponse::Ok().json(guild.unwrap()))
Ok(HttpResponse::Ok().json(guild))
}
#[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 {
return Ok(error);
}
check_access_token(auth_header, &mut data.pool.get().await.unwrap()).await?;
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 {
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()))
Ok(HttpResponse::Ok().json(guilds))
}

69
src/api/v1/servers/uuid/channels/mod.rs
View file

@ -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 log::error;
use actix_web::{HttpRequest, HttpResponse, get, post, web};
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);
if let Err(error) = auth_header {
return Ok(error);
}
let auth_header = get_auth_header(headers)?;
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 {
return Ok(error);
}
let uuid = check_access_token(auth_header, &mut conn).await?;
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!("{}_channels", guild_uuid)).await;
if let Ok(cache_hit) = cache_result {
if let Ok(cache_hit) = data.get_cache_key(format!("{}_channels", guild_uuid)).await {
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 {
return Ok(error);
}
let channels = channels_result.unwrap();
let cache_result = data
data
.set_cache_key(format!("{}_channels", guild_uuid), channels.clone(), 1800)
.await;
if let Err(error) = cache_result {
error!("{}", error);
return Ok(HttpResponse::InternalServerError().finish());
}
.await?;
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);
if let Err(error) = auth_header {
return Ok(error);
}
let auth_header = get_auth_header(headers)?;
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 {
return Ok(error);
}
let uuid = check_access_token(auth_header, &mut conn).await?;
let uuid = authorized.unwrap();
let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
if let Err(error) = member {
return Ok(error);
}
Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
// 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()))
}

57
src/api/v1/servers/uuid/channels/uuid/messages.rs
View file

@ -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 log::error;
use actix_web::{HttpRequest, HttpResponse, get, web};
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);
if let Err(error) = auth_header {
return Ok(error);
}
let auth_header = get_auth_header(headers)?;
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 {
return Ok(error);
}
let uuid = check_access_token(auth_header, &mut conn).await?;
let uuid = authorized.unwrap();
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;
Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
let channel: Channel;
if let Ok(cache_hit) = cache_result {
channel = serde_json::from_str(&cache_hit).unwrap()
if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
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 {
return Ok(error);
}
channel = channel_result.unwrap();
let cache_result = data
data
.set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
.await;
if let Err(error) = cache_result {
error!("{}", error);
return Ok(HttpResponse::InternalServerError().finish());
}
.await?;
}
let messages = channel
.fetch_messages(&data.pool, message_request.amount, message_request.offset)
.await;
.fetch_messages(&mut conn, message_request.amount, message_request.offset)
.await?;
if let Err(error) = messages {
return Ok(error);
}
Ok(HttpResponse::Ok().json(messages.unwrap()))
Ok(HttpResponse::Ok().json(messages))
}

91
src/api/v1/servers/uuid/channels/uuid/mod.rs
View file

@ -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 actix_web::{Error, HttpRequest, HttpResponse, delete, get, web};
use log::error;
use uuid::Uuid;
use actix_web::{HttpRequest, HttpResponse, delete, get, web};
#[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);
if let Err(error) = auth_header {
return Ok(error);
}
let auth_header = get_auth_header(headers)?;
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 {
return Ok(error);
}
let uuid = check_access_token(auth_header, &mut conn).await?;
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;
if let Ok(cache_hit) = cache_result {
if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
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 {
return Ok(error);
}
let channel = channel_result.unwrap();
let cache_result = data
data
.set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
.await;
if let Err(error) = cache_result {
error!("{}", error);
return Ok(HttpResponse::InternalServerError().finish());
}
.await?;
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);
if let Err(error) = auth_header {
return Ok(error);
}
let auth_header = get_auth_header(headers)?;
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 {
return Ok(error);
}
let uuid = check_access_token(auth_header, &mut conn).await?;
let uuid = authorized.unwrap();
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;
Member::fetch_one(&mut conn, uuid, guild_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;
if let Err(error) = result {
error!("{}", error)
}
data.del_cache_key(format!("{}", channel_uuid)).await?;
} else {
let channel_result = Channel::fetch_one(&data.pool, guild_uuid, channel_uuid).await;
if let Err(error) = channel_result {
return Ok(error);
}
channel = channel_result.unwrap();
channel = Channel::fetch_one(&mut conn, channel_uuid).await?;
}
let delete_result = channel.delete(&data.pool).await;
if let Err(error) = delete_result {
return Ok(error);
}
channel.delete(&mut conn).await?;
Ok(HttpResponse::Ok().finish())
}

56
src/api/v1/servers/uuid/channels/uuid/socket.rs
View file

@ -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);
if let Err(error) = auth_header {
return Ok(error);
}
let auth_header = get_auth_header(headers)?;
// 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;
if let Err(error) = authorized {
return Ok(error);
}
// Unwrap user uuid from authorization
let uuid = authorized.unwrap();
let uuid = check_access_token(auth_header, &mut conn).await?;
// Get server member from psql
let member = Member::fetch_one(&data.pool, 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;
Member::fetch_one(&mut conn, uuid, guild_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 {
return Ok(error);
}
channel = channel_result.unwrap();
let cache_result = data
data
.set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
.await;
if let Err(error) = cache_result {
error!("{}", error);
return Ok(HttpResponse::InternalServerError().finish());
}
.await?;
}
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;
if let Err(error) = pubsub_result {
error!("{}", error);
return Ok(HttpResponse::InternalServerError().finish());
}
let mut pubsub = data.cache_pool.get_async_pubsub().await.map_err(|e| crate::error::Error::from(e))?;
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();
}

36
src/api/v1/servers/uuid/icon.rs
View file

@ -1,8 +1,8 @@
use actix_web::{put, web, Error, HttpRequest, HttpResponse};
use actix_web::{put, web, HttpRequest, HttpResponse};
use uuid::Uuid;
use futures_util::StreamExt as _;
use crate::{api::v1::auth::check_access_token, structs::{Guild, Member}, utils::get_auth_header, Data};
use crate::{error::Error, api::v1::auth::check_access_token, structs::{Guild, Member}, utils::get_auth_header, Data};
#[put("{uuid}/icon")]
pub async fn upload(
@ -13,44 +13,24 @@ pub async fn upload(
) -> Result<HttpResponse, Error> {
let headers = req.headers();
let auth_header = get_auth_header(headers);
if let Err(error) = auth_header {
return Ok(error);
}
let auth_header = get_auth_header(headers)?;
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 {
return Ok(error);
}
let uuid = check_access_token(auth_header, &mut conn).await?;
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 guild_result = Guild::fetch_one(&data.pool, guild_uuid).await;
if let Err(error) = guild_result {
return Ok(error);
}
let mut guild = guild_result.unwrap();
let mut guild = Guild::fetch_one(&mut conn, guild_uuid).await?;
let mut bytes = web::BytesMut::new();
while let Some(item) = payload.next().await {
bytes.extend_from_slice(&item?);
}
if let Err(error) = guild.set_icon(&data.bunny_cdn, &data.pool, data.config.bunny.cdn_url.clone(), bytes).await {
return Ok(error)
}
guild.set_icon(&data.bunny_cdn, &mut conn, data.config.bunny.cdn_url.clone(), bytes).await?;
Ok(HttpResponse::Ok().finish())
}

77
src/api/v1/servers/uuid/invites/mod.rs
View file

@ -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);
if let Err(error) = auth_header {
return Ok(error);
}
let auth_header = get_auth_header(headers)?;
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 {
return Ok(error);
}
let uuid = check_access_token(auth_header, &mut conn).await?;
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 {
return Ok(error);
}
let invites = guild.get_invites(&mut conn).await?;
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 invites = guild.get_invites(&data.pool).await;
if let Err(error) = invites {
return Ok(error);
}
Ok(HttpResponse::Ok().json(invites.unwrap()))
Ok(HttpResponse::Ok().json(invites))
}
#[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);
if let Err(error) = auth_header {
return Ok(error);
}
let auth_header = get_auth_header(headers)?;
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 {
return Ok(error);
}
let uuid = check_access_token(auth_header, &mut conn).await?;
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;
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 guild = Guild::fetch_one(&mut conn, guild_uuid).await?;
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 {
return Ok(error);
}
Ok(HttpResponse::Ok().json(invite.unwrap()))
Ok(HttpResponse::Ok().json(invite))
}

31
src/api/v1/servers/uuid/mod.rs
View file

@ -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;
@ -7,6 +7,7 @@ mod roles;
mod icon;
use crate::{
error::Error,
Data,
api::v1::auth::check_access_token,
structs::{Guild, Member},
@ -43,33 +44,17 @@ pub async fn res(
) -> Result<HttpResponse, Error> {
let headers = req.headers();
let auth_header = get_auth_header(headers);
if let Err(error) = auth_header {
return Ok(error);
}
let auth_header = get_auth_header(headers)?;
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 {
return Ok(error);
}
let uuid = check_access_token(auth_header, &mut conn).await?;
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 {
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()))
Ok(HttpResponse::Ok().json(guild))
}

78
src/api/v1/servers/uuid/roles/mod.rs
View file

@ -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);
if let Err(error) = auth_header {
return Ok(error);
}
let auth_header = get_auth_header(headers)?;
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 {
return Ok(error);
}
let uuid = check_access_token(auth_header, &mut conn).await?;
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!("{}_roles", guild_uuid)).await;
if let Ok(cache_hit) = cache_result {
if let Ok(cache_hit) = data.get_cache_key(format!("{}_roles", guild_uuid)).await {
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 {
return Ok(error);
}
let roles = roles_result.unwrap();
let cache_result = data
data
.set_cache_key(format!("{}_roles", guild_uuid), roles.clone(), 1800)
.await;
if let Err(error) = cache_result {
error!("{}", error);
return Ok(HttpResponse::InternalServerError().finish());
}
.await?;
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);
if let Err(error) = auth_header {
return Ok(error);
}
let auth_header = get_auth_header(headers)?;
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 {
return Ok(error);
}
let uuid = check_access_token(auth_header, &mut conn).await?;
let uuid = authorized.unwrap();
let member = Member::fetch_one(&data.pool, uuid, guild_uuid).await;
if let Err(error) = member {
return Ok(error);
}
Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
// 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 {
return Ok(error);
}
Ok(HttpResponse::Ok().json(role.unwrap()))
Ok(HttpResponse::Ok().json(role))
}

45
src/api/v1/servers/uuid/roles/uuid.rs
View file

@ -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 log::error;
use actix_web::{HttpRequest, HttpResponse, get, web};
#[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);
if let Err(error) = auth_header {
return Ok(error);
}
let auth_header = get_auth_header(headers)?;
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 {
return Ok(error);
}
let uuid = check_access_token(auth_header, &mut conn).await?;
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!("{}", role_uuid)).await;
if let Ok(cache_hit) = cache_result {
if let Ok(cache_hit) = data.get_cache_key(format!("{}", role_uuid)).await {
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 {
return Ok(error);
}
let role = role_result.unwrap();
let cache_result = data
data
.set_cache_key(format!("{}", role_uuid), role.clone(), 60)
.await;
if let Err(error) = cache_result {
error!("{}", error);
return Ok(HttpResponse::InternalServerError().finish());
}
.await?;
Ok(HttpResponse::Ok().json(role))
}

26
src/api/v1/stats.rs
View file

@ -1,31 +1,31 @@
use std::time::SystemTime;
use actix_web::{HttpResponse, Responder, get, web};
use actix_web::{HttpResponse, get, web};
use diesel::QueryDsl;
use diesel_async::RunQueryDsl;
use serde::Serialize;
use crate::error::Error;
use crate::Data;
use crate::schema::users::dsl::{users, uuid};
const VERSION: Option<&'static str> = option_env!("CARGO_PKG_VERSION");
#[derive(Serialize)]
struct Response {
accounts: usize,
accounts: i64,
uptime: u64,
version: String,
build_number: String,
}
#[get("/stats")]
pub async fn res(data: web::Data<Data>) -> impl Responder {
let accounts;
if let Ok(users) = sqlx::query("SELECT uuid FROM users")
.fetch_all(&data.pool)
.await
{
accounts = users.len();
} else {
return HttpResponse::InternalServerError().finish();
}
pub async fn res(data: web::Data<Data>) -> Result<HttpResponse, Error> {
let accounts: i64 = users
.select(uuid)
.count()
.get_result(&mut data.pool.get().await?)
.await?;
let response = Response {
// TODO: Get number of accounts from db
@ -39,5 +39,5 @@ pub async fn res(data: web::Data<Data>) -> impl Responder {
build_number: String::from("how do i implement this?"),
};
HttpResponse::Ok().json(response)
Ok(HttpResponse::Ok().json(response))
}

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

@ -1,33 +1,21 @@
use actix_web::{get, patch, web, Error, HttpRequest, HttpResponse};
use actix_web::{get, patch, web, HttpRequest, HttpResponse};
use serde::Deserialize;
use crate::{api::v1::auth::check_access_token, structs::Me, utils::get_auth_header, Data};
use crate::{error::Error, structs::Me, api::v1::auth::check_access_token, utils::get_auth_header, Data};
#[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 me = Me::get(&mut conn, uuid).await?;
let uuid = authorized.unwrap();
let me = Me::get(&data.pool, uuid).await;
if let Err(error) = me {
return Ok(error);
}
Ok(HttpResponse::Ok().json(me.unwrap()))
Ok(HttpResponse::Ok().json(me))
}
#[derive(Deserialize)]
@ -42,27 +30,13 @@ struct NewInfo {
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);
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 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.unwrap();
let me = Me::get(&mut conn, uuid).await?;
if let Some(username) = &new_info.username {
todo!();

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

@ -1,5 +1,6 @@
use crate::{api::v1::auth::check_access_token, structs::{StartAmountQuery, User}, utils::get_auth_header, Data};
use actix_web::{Error, HttpRequest, HttpResponse, Scope, get, web};
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, Data};
mod me;
mod uuid;
@ -19,7 +20,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);
@ -29,17 +30,11 @@ 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 accounts = User::fetch_amount(&data.pool, start, amount).await;
let users = User::fetch_amount(&mut conn, start, amount).await?;
if let Err(error) = accounts {
return Ok(error);
}
Ok(HttpResponse::Ok().json(accounts.unwrap()))
Ok(HttpResponse::Ok().json(users))
}

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

@ -1,8 +1,8 @@
use actix_web::{Error, HttpRequest, HttpResponse, get, web};
use log::error;
use actix_web::{HttpRequest, HttpResponse, get, web};
use uuid::Uuid;
use crate::{api::v1::auth::check_access_token, structs::User, utils::get_auth_header, Data};
use crate::{error::Error, api::v1::auth::check_access_token, structs::User, utils::get_auth_header, Data};
#[get("/{uuid}")]
pub async fn res(
@ -14,42 +14,23 @@ 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;
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;
if let Ok(cache_hit) = cache_result {
if let Ok(cache_hit) = data.get_cache_key(uuid.to_string()).await {
return Ok(HttpResponse::Ok()
.content_type("application/json")
.body(cache_hit));
}
let user_result = User::fetch_one(&data.pool, uuid).await;
let user = User::fetch_one(&mut conn, uuid).await?;
if let Err(error) = user_result {
return Ok(error);
}
let user = user_result.unwrap();
let cache_result = data
data
.set_cache_key(uuid.to_string(), user.clone(), 1800)
.await;
if let Err(error) = cache_result {
error!("{}", error);
return Ok(HttpResponse::InternalServerError().finish());
}
.await?;
Ok(HttpResponse::Ok().json(user))
}