style: move channels to /channels

src/api/v1/channels/uuid/messages.rs

@@ -0,0 +1,74 @@
+//! `/api/v1/servers/{uuid}/channels/{uuid}/messages` Endpoints related to channel messages
+
+use crate::{
+    api::v1::auth::check_access_token, error::Error, structs::{Channel, Member}, utils::{get_auth_header, global_checks}, Data
+};
+use ::uuid::Uuid;
+use actix_web::{HttpRequest, HttpResponse, get, web};
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+struct MessageRequest {
+    amount: i64,
+    offset: i64,
+}
+
+/// `GET /api/v1/servers/{uuid}/channels/{uuid}/messages` Returns user with the given UUID
+/// 
+/// requires auth: yes
+/// 
+/// requires relation: yes
+/// 
+/// ### Request Example
+/// ```
+/// json!({
+///     "amount": 100,
+///     "offset": 0
+/// })
+/// ```
+/// 
+/// ### Response Example
+/// ```
+/// json!({
+///     "uuid": "01971976-8618-74c0-b040-7ffbc44823f6",
+///     "channel_uuid": "0196fcb1-e886-7de3-b685-0ee46def9a7b",
+///     "user_uuid": "0196fc96-a822-76b0-b9bf-a9de232f54b7",
+///     "message": "test",
+///     "user": {
+///         "uuid": "0196fc96-a822-76b0-b9bf-a9de232f54b7",
+///         "username": "1234",
+///         "display_name": null,
+///         "avatar": "https://cdn.gorb.app/avatar/0196fc96-a822-76b0-b9bf-a9de232f54b7/avatar.jpg"
+///     }
+/// });
+/// ```
+/// 
+#[get("/{uuid}/messages")]
+pub async fn get(
+    req: HttpRequest,
+    path: web::Path<(Uuid,)>,
+    message_request: web::Query<MessageRequest>,
+    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?;
+
+    let messages = channel
+        .fetch_messages(&data, message_request.amount, message_request.offset)
+        .await?;
+
+    Ok(HttpResponse::Ok().json(messages))
+}

src/api/v1/channels/uuid/mod.rs

@@ -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())
+}

src/api/v1/channels/uuid/socket.rs

@@ -0,0 +1,111 @@
+use actix_web::{
+    Error, HttpRequest, HttpResponse, get,
+    http::header::{HeaderValue, SEC_WEBSOCKET_PROTOCOL},
+    rt, web,
+};
+use actix_ws::AggregatedMessage;
+use futures_util::StreamExt as _;
+use uuid::Uuid;
+
+use crate::{
+    api::v1::auth::check_access_token, structs::{Channel, Member}, utils::{get_ws_protocol_header, global_checks}, Data
+};
+
+#[get("/{uuid}/socket")]
+pub async fn ws(
+    req: HttpRequest,
+    path: web::Path<(Uuid,)>,
+    stream: web::Payload,
+    data: web::Data<Data>,
+) -> Result<HttpResponse, Error> {
+    // Get all headers
+    let headers = req.headers();
+
+    // Retrieve auth header
+    let auth_header = get_ws_protocol_header(headers)?;
+
+    // Get uuid from path
+    let channel_uuid = path.into_inner().0;
+
+    let mut conn = data.pool.get().await.map_err(crate::error::Error::from)?;
+
+    // Authorize client using auth header
+    let uuid = check_access_token(auth_header, &mut conn).await?;
+
+    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, channel.guild_uuid).await?;
+
+    let (mut res, mut session_1, stream) = actix_ws::handle(&req, stream)?;
+
+    let mut stream = stream
+        .aggregate_continuations()
+        // aggregate continuation frames up to 1MiB
+        .max_continuation_size(2_usize.pow(20));
+
+    let mut pubsub = data
+        .cache_pool
+        .get_async_pubsub()
+        .await
+        .map_err(crate::error::Error::from)?;
+
+    let mut session_2 = session_1.clone();
+
+    rt::spawn(async move {
+        pubsub.subscribe(channel_uuid.to_string()).await?;
+        while let Some(msg) = pubsub.on_message().next().await {
+            let payload: String = msg.get_payload()?;
+            session_1.text(payload).await?;
+        }
+
+        Ok::<(), crate::error::Error>(())
+    });
+
+    // start task but don't wait for it
+    rt::spawn(async move {
+        // receive messages from websocket
+        while let Some(msg) = stream.next().await {
+            match msg {
+                Ok(AggregatedMessage::Text(text)) => {
+                    let mut conn = data.cache_pool.get_multiplexed_tokio_connection().await?;
+
+                    let message = channel
+                        .new_message(&data, uuid, text.to_string())
+                        .await?;
+
+                    redis::cmd("PUBLISH")
+                        .arg(&[channel_uuid.to_string(), serde_json::to_string(&message)?])
+                        .exec_async(&mut conn)
+                        .await?;
+                }
+
+                Ok(AggregatedMessage::Binary(bin)) => {
+                    // echo binary message
+                    session_2.binary(bin).await?;
+                }
+
+                Ok(AggregatedMessage::Ping(msg)) => {
+                    // respond to PING frame with PONG frame
+                    session_2.pong(&msg).await?;
+                }
+
+                _ => {}
+            }
+        }
+
+        Ok::<(), crate::error::Error>(())
+    });
+
+    let headers = res.headers_mut();
+
+    headers.append(
+        SEC_WEBSOCKET_PROTOCOL,
+        HeaderValue::from_str("Authorization")?,
+    );
+
+    // respond immediately with response connected to WS session
+    Ok(res)
+}