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

style: move channels to /channels

Browse source
This commit is contained in:
Radical 2025-05-29 20:11:50 +02:00
parent 461295c14a
commit 66c3aef609
9 changed files with 111 additions and 121 deletions
Download patch file Download diff file Expand all files Collapse all files

11
src/api/v1/channels/mod.rs Normal file
View file

@ -0,0 +1,11 @@
use actix_web::{web, Scope};
mod uuid;
pub fn web() -> Scope {
web::scope("/channels")
.service(uuid::get)
.service(uuid::delete)
.service(uuid::messages::get)
.service(uuid::socket::ws)
}

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

@ -43,10 +43,10 @@ struct MessageRequest {
/// });
/// ```
///
#[get("{uuid}/channels/{channel_uuid}/messages")]
#[get("/{uuid}/messages")]
pub async fn get(
req: HttpRequest,
path: web::Path<(Uuid, Uuid)>,
path: web::Path<(Uuid,)>,
message_request: web::Query<MessageRequest>,
data: web::Data<Data>,
) -> Result<HttpResponse, Error> {
@ -54,7 +54,7 @@ pub async fn get(
let auth_header = get_auth_header(headers)?;
let (guild_uuid, channel_uuid) = path.into_inner();
let channel_uuid = path.into_inner().0;
let mut conn = data.pool.get().await?;
@ -62,18 +62,9 @@ pub async fn get(
global_checks(&data, uuid).await?;
Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
let channel = Channel::fetch_one(&data, channel_uuid).await?;
let channel: Channel;
if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
channel = serde_json::from_str(&cache_hit)?
} else {
channel = Channel::fetch_one(&mut conn, channel_uuid).await?;
data.set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
.await?;
}
Member::fetch_one(&mut conn, uuid, channel.guild_uuid).await?;
let messages = channel
.fetch_messages(&data, message_request.amount, message_request.offset)

60
src/api/v1/channels/uuid/mod.rs Normal file
View file

@ -0,0 +1,60 @@
pub mod messages;
pub mod socket;
use crate::{
api::v1::auth::check_access_token, error::Error, structs::{Channel, Member}, utils::{get_auth_header, global_checks}, Data
};
use actix_web::{HttpRequest, HttpResponse, delete, get, web};
use uuid::Uuid;
#[get("/{uuid}")]
pub async fn get(
req: HttpRequest,
path: web::Path<(Uuid,)>,
data: web::Data<Data>,
) -> Result<HttpResponse, Error> {
let headers = req.headers();
let auth_header = get_auth_header(headers)?;
let channel_uuid = path.into_inner().0;
let mut conn = data.pool.get().await?;
let uuid = check_access_token(auth_header, &mut conn).await?;
global_checks(&data, uuid).await?;
let channel = Channel::fetch_one(&data, channel_uuid).await?;
Member::fetch_one(&mut conn, uuid, channel.guild_uuid).await?;
Ok(HttpResponse::Ok().json(channel))
}
#[delete("/{uuid}")]
pub async fn delete(
req: HttpRequest,
path: web::Path<(Uuid,)>,
data: web::Data<Data>,
) -> Result<HttpResponse, Error> {
let headers = req.headers();
let auth_header = get_auth_header(headers)?;
let channel_uuid = path.into_inner().0;
let mut conn = data.pool.get().await?;
let uuid = check_access_token(auth_header, &mut conn).await?;
global_checks(&data, uuid).await?;
let channel = Channel::fetch_one(&data, channel_uuid).await?;
Member::fetch_one(&mut conn, uuid, channel.guild_uuid).await?;
channel.delete(&data).await?;
Ok(HttpResponse::Ok().finish())
}

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

@ -11,10 +11,10 @@ use crate::{
api::v1::auth::check_access_token, structs::{Channel, Member}, utils::{get_ws_protocol_header, global_checks}, Data
};
#[get("{uuid}/channels/{channel_uuid}/socket")]
#[get("/{uuid}/socket")]
pub async fn ws(
req: HttpRequest,
path: web::Path<(Uuid, Uuid)>,
path: web::Path<(Uuid,)>,
stream: web::Payload,
data: web::Data<Data>,
) -> Result<HttpResponse, Error> {
@ -24,8 +24,8 @@ pub async fn ws(
// Retrieve auth header
let auth_header = get_ws_protocol_header(headers)?;
// Get uuids from path
let (guild_uuid, channel_uuid) = path.into_inner();
// Get uuid from path
let channel_uuid = path.into_inner().0;
let mut conn = data.pool.get().await.map_err(crate::error::Error::from)?;
@ -34,20 +34,10 @@ pub async fn ws(
global_checks(&data, uuid).await?;
let channel = Channel::fetch_one(&data, channel_uuid).await?;
// Get server member from psql
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) = data.get_cache_key(format!("{}", channel_uuid)).await {
channel = serde_json::from_str(&cache_hit)?
} else {
channel = Channel::fetch_one(&mut conn, channel_uuid).await?;
data.set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
.await?;
}
Member::fetch_one(&mut conn, uuid, channel.guild_uuid).await?;
let (mut res, mut session_1, stream) = actix_ws::handle(&req, stream)?;

2
src/api/v1/mod.rs
View file

@ -3,6 +3,7 @@
use actix_web::{Scope, web};
mod auth;
mod channels;
mod invites;
mod servers;
mod stats;
@ -14,6 +15,7 @@ pub fn web() -> Scope {
.service(stats::res)
.service(auth::web())
.service(users::web())
.service(channels::web())
.service(servers::web())
.service(invites::web())
.service(me::web())

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

@ -5,8 +5,6 @@ use ::uuid::Uuid;
use actix_web::{HttpRequest, HttpResponse, get, post, web};
use serde::Deserialize;
pub mod uuid;
#[derive(Deserialize)]
struct ChannelInfo {
name: String,

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

@ -1,77 +0,0 @@
pub mod messages;
pub mod socket;
use crate::{
api::v1::auth::check_access_token, error::Error, structs::{Channel, Member}, utils::{get_auth_header, global_checks}, Data
};
use actix_web::{HttpRequest, HttpResponse, delete, get, web};
use uuid::Uuid;
#[get("{uuid}/channels/{channel_uuid}")]
pub async fn get(
req: HttpRequest,
path: web::Path<(Uuid, Uuid)>,
data: web::Data<Data>,
) -> Result<HttpResponse, Error> {
let headers = req.headers();
let auth_header = get_auth_header(headers)?;
let (guild_uuid, channel_uuid) = path.into_inner();
let mut conn = data.pool.get().await?;
let uuid = check_access_token(auth_header, &mut conn).await?;
global_checks(&data, uuid).await?;
Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
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 = Channel::fetch_one(&mut conn, channel_uuid).await?;
data.set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
.await?;
Ok(HttpResponse::Ok().json(channel))
}
#[delete("{uuid}/channels/{channel_uuid}")]
pub async fn delete(
req: HttpRequest,
path: web::Path<(Uuid, Uuid)>,
data: web::Data<Data>,
) -> Result<HttpResponse, Error> {
let headers = req.headers();
let auth_header = get_auth_header(headers)?;
let (guild_uuid, channel_uuid) = path.into_inner();
let mut conn = data.pool.get().await?;
let uuid = check_access_token(auth_header, &mut conn).await?;
global_checks(&data, uuid).await?;
Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
let channel: Channel;
if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
channel = serde_json::from_str(&cache_hit)?;
data.del_cache_key(format!("{}", channel_uuid)).await?;
} else {
channel = Channel::fetch_one(&mut conn, channel_uuid).await?;
}
channel.delete(&mut conn).await?;
Ok(HttpResponse::Ok().finish())
}

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

@ -19,10 +19,6 @@ pub fn web() -> Scope {
// Channels
.service(channels::get)
.service(channels::create)
.service(channels::uuid::get)
.service(channels::uuid::delete)
.service(channels::uuid::messages::get)
.service(channels::uuid::socket::ws)
// Roles
.service(roles::get)
.service(roles::create)

29
src/structs.rs
View file

@ -183,15 +183,26 @@ impl Channel {
futures::future::try_join_all(channel_futures).await
}
pub async fn fetch_one(conn: &mut Conn, channel_uuid: Uuid) -> Result<Self, Error> {
pub async fn fetch_one(data: &Data, channel_uuid: Uuid) -> Result<Self, Error> {
if let Ok(cache_hit) = data.get_cache_key(channel_uuid.to_string()).await {
return Ok(serde_json::from_str(&cache_hit)?);
}
let mut conn = data.pool.get().await?;
use channels::dsl;
let channel_builder: ChannelBuilder = dsl::channels
.filter(dsl::uuid.eq(channel_uuid))
.select(ChannelBuilder::as_select())
.get_result(conn)
.get_result(&mut conn)
.await?;
channel_builder.build(conn).await
let channel = channel_builder.build(&mut conn).await?;
data.set_cache_key(channel_uuid.to_string(), channel.clone(), 60)
.await?;
Ok(channel)
}
pub async fn new(
@ -245,19 +256,27 @@ impl Channel {
data.set_cache_key(channel_uuid.to_string(), channel.clone(), 1800)
.await?;
if let Ok(_) = data.get_cache_key(format!("{}_channels", guild_uuid)).await {
data.del_cache_key(format!("{}_channels", guild_uuid))
.await?;
}
Ok(channel)
}
pub async fn delete(self, conn: &mut Conn) -> Result<(), Error> {
pub async fn delete(self, data: &Data) -> Result<(), Error> {
let mut conn = data.pool.get().await?;
use channels::dsl;
delete(channels::table)
.filter(dsl::uuid.eq(self.uuid))
.execute(conn)
.execute(&mut conn)
.await?;
if let Ok(_) = data.get_cache_key(self.uuid.to_string()).await {
data.del_cache_key(self.uuid.to_string()).await?;
}
Ok(())
}