109 lines
2.9 KiB
Rust
109 lines
2.9 KiB
Rust
use std::str::FromStr;
|
|
|
|
use actix_web::{get, web, Error, HttpRequest, HttpResponse};
|
|
use serde::Serialize;
|
|
use sqlx::{prelude::FromRow, Pool, Postgres};
|
|
use crate::{api::v1::auth::check_access_token, utils::get_auth_header, Data};
|
|
use ::uuid::Uuid;
|
|
use log::error;
|
|
|
|
mod uuid;
|
|
|
|
#[derive(Serialize, FromRow)]
|
|
struct ChannelPermission {
|
|
role_uuid: String,
|
|
permissions: i32
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct Channel {
|
|
uuid: String,
|
|
name: String,
|
|
description: Option<String>,
|
|
permissions: Vec<ChannelPermission>
|
|
}
|
|
|
|
impl Channel {
|
|
async fn fetch_all(pool: &Pool<Postgres>, guild_uuid: Uuid) -> Result<Vec<Self>, HttpResponse> {
|
|
let row = sqlx::query_as(&format!("SELECT uuid, name, description FROM channels WHERE guild_uuid = '{}'", guild_uuid))
|
|
.fetch_all(pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish())
|
|
}
|
|
|
|
let channels: Vec<(String, String, Option<String>)> = row.unwrap();
|
|
|
|
let futures = channels.iter().map(async |t| {
|
|
let (uuid, name, description) = t.to_owned();
|
|
|
|
let row = sqlx::query_as(&format!("SELECT role_uuid, permissions FROM channel_permissions WHERE channel_uuid = '{}'", uuid))
|
|
.fetch_all(pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish())
|
|
}
|
|
|
|
Ok(Self {
|
|
uuid,
|
|
name,
|
|
description,
|
|
permissions: row.unwrap(),
|
|
})
|
|
});
|
|
|
|
let channels = futures::future::join_all(futures).await;
|
|
|
|
let channels: Result<Vec<Channel>, HttpResponse> = channels.into_iter().collect();
|
|
|
|
Ok(channels?)
|
|
}
|
|
}
|
|
|
|
#[get("{uuid}/channels")]
|
|
pub async fn response(req: HttpRequest, path: web::Path<(Uuid,)>, 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 guild_uuid = path.into_inner().0;
|
|
|
|
let authorized = check_access_token(auth_header.unwrap(), &data.pool).await;
|
|
|
|
if let Err(error) = authorized {
|
|
return Ok(error)
|
|
}
|
|
|
|
let uuid = authorized.unwrap();
|
|
|
|
let row: Result<String, sqlx::Error> = sqlx::query_scalar(&format!("SELECT CAST(uuid AS VARCHAR) FROM guild_members WHERE guild_uuid = '{}' AND user_uuid = '{}'", guild_uuid, uuid))
|
|
.fetch_one(&data.pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
|
|
return Ok(HttpResponse::InternalServerError().finish())
|
|
}
|
|
|
|
let member_uuid = Uuid::from_str(&row.unwrap()).unwrap();
|
|
|
|
|
|
let channels = Channel::fetch_all(&data.pool, guild_uuid).await;
|
|
|
|
if let Err(error) = channels {
|
|
return Ok(error)
|
|
}
|
|
|
|
Ok(HttpResponse::Ok().json(channels.unwrap()))
|
|
}
|