forked from gorb/backend
904 lines
24 KiB
Rust
904 lines
24 KiB
Rust
use std::str::FromStr;
|
|
|
|
use actix_web::{web::BytesMut, HttpResponse};
|
|
use bindet::FileType;
|
|
use log::error;
|
|
use serde::{Deserialize, Serialize};
|
|
use sqlx::{Pool, Postgres, prelude::FromRow};
|
|
use tokio::task;
|
|
use url::Url;
|
|
use uuid::Uuid;
|
|
|
|
use crate::Data;
|
|
|
|
#[derive(Serialize, Deserialize, Clone)]
|
|
pub struct Channel {
|
|
pub uuid: Uuid,
|
|
pub guild_uuid: Uuid,
|
|
name: String,
|
|
description: Option<String>,
|
|
pub permissions: Vec<ChannelPermission>,
|
|
}
|
|
|
|
#[derive(Serialize, Clone, FromRow)]
|
|
struct ChannelPermissionBuilder {
|
|
role_uuid: String,
|
|
permissions: i32,
|
|
}
|
|
|
|
impl ChannelPermissionBuilder {
|
|
fn build(&self) -> ChannelPermission {
|
|
ChannelPermission {
|
|
role_uuid: Uuid::from_str(&self.role_uuid).unwrap(),
|
|
permissions: self.permissions,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Clone, FromRow)]
|
|
pub struct ChannelPermission {
|
|
pub role_uuid: Uuid,
|
|
pub permissions: i32,
|
|
}
|
|
|
|
impl Channel {
|
|
pub async fn fetch_all(
|
|
pool: &Pool<Postgres>,
|
|
guild_uuid: Uuid,
|
|
) -> Result<Vec<Self>, HttpResponse> {
|
|
let row = sqlx::query_as(&format!(
|
|
"SELECT CAST(uuid AS VARCHAR), 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 CAST(role_uuid AS VARCHAR), permissions FROM channel_permissions WHERE channel_uuid = '{}'", uuid))
|
|
.fetch_all(pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish())
|
|
}
|
|
|
|
let channel_permission_builders: Vec<ChannelPermissionBuilder> = row.unwrap();
|
|
|
|
Ok(Self {
|
|
uuid: Uuid::from_str(&uuid).unwrap(),
|
|
guild_uuid,
|
|
name,
|
|
description,
|
|
permissions: channel_permission_builders.iter().map(|b| b.build()).collect(),
|
|
})
|
|
});
|
|
|
|
let channels = futures::future::join_all(futures).await;
|
|
|
|
let channels: Result<Vec<Channel>, HttpResponse> = channels.into_iter().collect();
|
|
|
|
channels
|
|
}
|
|
|
|
pub async fn fetch_one(
|
|
pool: &Pool<Postgres>,
|
|
guild_uuid: Uuid,
|
|
channel_uuid: Uuid,
|
|
) -> Result<Self, HttpResponse> {
|
|
let row = sqlx::query_as(&format!(
|
|
"SELECT name, description FROM channels WHERE guild_uuid = '{}' AND uuid = '{}'",
|
|
guild_uuid, channel_uuid
|
|
))
|
|
.fetch_one(pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
let (name, description): (String, Option<String>) = row.unwrap();
|
|
|
|
let row = sqlx::query_as(&format!("SELECT CAST(role_uuid AS VARCHAR), permissions FROM channel_permissions WHERE channel_uuid = '{}'", channel_uuid))
|
|
.fetch_all(pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
let channel_permission_builders: Vec<ChannelPermissionBuilder> = row.unwrap();
|
|
|
|
Ok(Self {
|
|
uuid: channel_uuid,
|
|
guild_uuid,
|
|
name,
|
|
description,
|
|
permissions: channel_permission_builders
|
|
.iter()
|
|
.map(|b| b.build())
|
|
.collect(),
|
|
})
|
|
}
|
|
|
|
pub async fn new(
|
|
data: actix_web::web::Data<Data>,
|
|
guild_uuid: Uuid,
|
|
name: String,
|
|
description: Option<String>,
|
|
) -> Result<Self, HttpResponse> {
|
|
let channel_uuid = Uuid::now_v7();
|
|
|
|
let row = sqlx::query(&format!("INSERT INTO channels (uuid, guild_uuid, name, description) VALUES ('{}', '{}', $1, $2)", channel_uuid, guild_uuid))
|
|
.bind(&name)
|
|
.bind(&description)
|
|
.execute(&data.pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
let channel = Self {
|
|
uuid: channel_uuid,
|
|
guild_uuid,
|
|
name,
|
|
description,
|
|
permissions: vec![],
|
|
};
|
|
|
|
let cache_result = data
|
|
.set_cache_key(channel_uuid.to_string(), channel.clone(), 1800)
|
|
.await;
|
|
|
|
if let Err(error) = cache_result {
|
|
error!("{}", error);
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
let cache_deletion_result = data.del_cache_key(format!("{}_channels", guild_uuid)).await;
|
|
|
|
if let Err(error) = cache_deletion_result {
|
|
error!("{}", error);
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
Ok(channel)
|
|
}
|
|
|
|
pub async fn delete(self, pool: &Pool<Postgres>) -> Result<(), HttpResponse> {
|
|
let result = sqlx::query(&format!(
|
|
"DELETE FROM channels WHERE channel_uuid = '{}'",
|
|
self.uuid
|
|
))
|
|
.execute(pool)
|
|
.await;
|
|
|
|
if let Err(error) = result {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn fetch_messages(
|
|
&self,
|
|
pool: &Pool<Postgres>,
|
|
amount: i64,
|
|
offset: i64,
|
|
) -> Result<Vec<Message>, HttpResponse> {
|
|
let row = sqlx::query_as(&format!("SELECT CAST(uuid AS VARCHAR), CAST(user_uuid AS VARCHAR), CAST(channel_uuid AS VARCHAR), message FROM messages WHERE channel_uuid = '{}' ORDER BY uuid DESC LIMIT $1 OFFSET $2", self.uuid))
|
|
.bind(amount)
|
|
.bind(offset)
|
|
.fetch_all(pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
let message_builders: Vec<MessageBuilder> = row.unwrap();
|
|
|
|
Ok(message_builders.iter().map(|b| b.build()).collect())
|
|
}
|
|
|
|
pub async fn new_message(
|
|
&self,
|
|
pool: &Pool<Postgres>,
|
|
user_uuid: Uuid,
|
|
message: String,
|
|
) -> Result<Message, HttpResponse> {
|
|
let message_uuid = Uuid::now_v7();
|
|
|
|
let row = sqlx::query(&format!("INSERT INTO messages (uuid, channel_uuid, user_uuid, message) VALUES ('{}', '{}', '{}', $1)", message_uuid, self.uuid, user_uuid))
|
|
.bind(&message)
|
|
.execute(pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
Ok(Message {
|
|
uuid: message_uuid,
|
|
channel_uuid: self.uuid,
|
|
user_uuid,
|
|
message,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy)]
|
|
pub enum Permissions {
|
|
SendMessage = 1,
|
|
CreateChannel = 2,
|
|
DeleteChannel = 4,
|
|
ManageChannel = 8,
|
|
CreateRole = 16,
|
|
DeleteRole = 32,
|
|
ManageRole = 64,
|
|
CreateInvite = 128,
|
|
ManageInvite = 256,
|
|
ManageServer = 512,
|
|
ManageMember = 1024,
|
|
}
|
|
|
|
impl Permissions {
|
|
pub fn fetch_permissions(permissions: i64) -> Vec<Self> {
|
|
let all_perms = vec![
|
|
Self::SendMessage,
|
|
Self::CreateChannel,
|
|
Self::DeleteChannel,
|
|
Self::ManageChannel,
|
|
Self::CreateRole,
|
|
Self::DeleteRole,
|
|
Self::ManageRole,
|
|
Self::CreateInvite,
|
|
Self::ManageInvite,
|
|
Self::ManageServer,
|
|
Self::ManageMember,
|
|
];
|
|
|
|
all_perms
|
|
.into_iter()
|
|
.filter(|p| permissions & (*p as i64) != 0)
|
|
.collect()
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
pub struct Guild {
|
|
pub uuid: Uuid,
|
|
name: String,
|
|
description: Option<String>,
|
|
icon: Option<String>,
|
|
owner_uuid: Uuid,
|
|
pub roles: Vec<Role>,
|
|
member_count: i64,
|
|
}
|
|
|
|
impl Guild {
|
|
pub async fn fetch_one(pool: &Pool<Postgres>, guild_uuid: Uuid) -> Result<Self, HttpResponse> {
|
|
let row = sqlx::query_as(&format!(
|
|
"SELECT CAST(owner_uuid AS VARCHAR), name, description, icon FROM guilds WHERE uuid = '{}'",
|
|
guild_uuid
|
|
))
|
|
.fetch_one(pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
let (owner_uuid_raw, name, description, icon): (String, String, Option<String>, Option<String>) = row.unwrap();
|
|
|
|
let owner_uuid = Uuid::from_str(&owner_uuid_raw).unwrap();
|
|
|
|
let member_count = Member::count(pool, guild_uuid).await?;
|
|
|
|
let roles = Role::fetch_all(pool, guild_uuid).await?;
|
|
|
|
Ok(Self {
|
|
uuid: guild_uuid,
|
|
name,
|
|
description,
|
|
icon,
|
|
owner_uuid,
|
|
roles,
|
|
member_count,
|
|
})
|
|
}
|
|
|
|
pub async fn new(
|
|
pool: &Pool<Postgres>,
|
|
name: String,
|
|
description: Option<String>,
|
|
owner_uuid: Uuid,
|
|
) -> Result<Self, HttpResponse> {
|
|
let guild_uuid = Uuid::now_v7();
|
|
|
|
let row = sqlx::query(&format!(
|
|
"INSERT INTO guilds (uuid, owner_uuid, name, description) VALUES ('{}', '{}', $1, $2)",
|
|
guild_uuid, owner_uuid
|
|
))
|
|
.bind(&name)
|
|
.bind(&description)
|
|
.execute(pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
let row = sqlx::query(&format!(
|
|
"INSERT INTO guild_members (uuid, guild_uuid, user_uuid) VALUES ('{}', '{}', '{}')",
|
|
Uuid::now_v7(),
|
|
guild_uuid,
|
|
owner_uuid
|
|
))
|
|
.execute(pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
|
|
let row = sqlx::query(&format!("DELETE FROM guilds WHERE uuid = '{}'", guild_uuid))
|
|
.execute(pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
}
|
|
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
Ok(Guild {
|
|
uuid: guild_uuid,
|
|
name,
|
|
description,
|
|
icon: None,
|
|
owner_uuid,
|
|
roles: vec![],
|
|
member_count: 1,
|
|
})
|
|
}
|
|
|
|
pub async fn get_invites(&self, pool: &Pool<Postgres>) -> Result<Vec<Invite>, HttpResponse> {
|
|
let invites = sqlx::query_as(&format!(
|
|
"SELECT (id, guild_uuid, user_uuid) FROM invites WHERE guild_uuid = '{}'",
|
|
self.uuid
|
|
))
|
|
.fetch_all(pool)
|
|
.await;
|
|
|
|
if let Err(error) = invites {
|
|
error!("{}", error);
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
Ok(invites
|
|
.unwrap()
|
|
.iter()
|
|
.map(|b: &InviteBuilder| b.build())
|
|
.collect())
|
|
}
|
|
|
|
pub async fn create_invite(
|
|
&self,
|
|
pool: &Pool<Postgres>,
|
|
member: &Member,
|
|
custom_id: Option<String>,
|
|
) -> Result<Invite, HttpResponse> {
|
|
let invite_id;
|
|
|
|
if custom_id.is_none() {
|
|
let charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
|
|
|
|
invite_id = random_string::generate(8, charset);
|
|
} else {
|
|
invite_id = custom_id.unwrap();
|
|
if invite_id.len() > 32 {
|
|
return Err(HttpResponse::BadRequest().finish());
|
|
}
|
|
}
|
|
|
|
let result = sqlx::query(&format!(
|
|
"INSERT INTO invites (id, guild_uuid, user_uuid) VALUES ($1, '{}', '{}'",
|
|
self.uuid, member.user_uuid
|
|
))
|
|
.bind(&invite_id)
|
|
.execute(pool)
|
|
.await;
|
|
|
|
if let Err(error) = result {
|
|
error!("{}", error);
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
Ok(Invite {
|
|
id: invite_id,
|
|
user_uuid: member.user_uuid,
|
|
guild_uuid: self.uuid,
|
|
})
|
|
}
|
|
|
|
// FIXME: Horrible security
|
|
pub async fn set_icon(&mut self, bunny_cdn: &bunny_api_tokio::Client, pool: &Pool<Postgres>, cdn_url: Url, icon: BytesMut) -> Result<(), HttpResponse> {
|
|
let ico = icon.clone();
|
|
|
|
let result = task::spawn_blocking(move || {
|
|
let buf = std::io::Cursor::new(ico.to_vec());
|
|
|
|
let detect = bindet::detect(buf).map_err(|e| e.kind());
|
|
|
|
if let Ok(Some(file_type)) = detect {
|
|
if file_type.likely_to_be == vec![FileType::Jpg] {
|
|
return String::from("jpg")
|
|
} else if file_type.likely_to_be == vec![FileType::Png] {
|
|
return String::from("png")
|
|
}
|
|
}
|
|
String::from("unknown")
|
|
}).await;
|
|
|
|
if let Err(error) = result {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish())
|
|
}
|
|
|
|
let image_type = result.unwrap();
|
|
|
|
if image_type == "unknown" {
|
|
return Err(HttpResponse::BadRequest().finish())
|
|
}
|
|
|
|
if let Some(icon) = &self.icon {
|
|
let relative_url = icon.trim_start_matches("https://cdn.gorb.app/");
|
|
|
|
let delete_result = bunny_cdn.storage.delete(relative_url).await;
|
|
|
|
if let Err(error) = delete_result {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish())
|
|
}
|
|
}
|
|
|
|
let path = format!("icons/{}/icon.{}", self.uuid, image_type);
|
|
|
|
let upload_result = bunny_cdn.storage.upload(path.clone(), icon.into()).await;
|
|
|
|
if let Err(error) = upload_result {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish())
|
|
}
|
|
|
|
|
|
let icon_url = cdn_url.join(&path).unwrap();
|
|
|
|
let row = sqlx::query(&format!("UPDATE guilds SET icon = $1 WHERE uuid = '{}'", self.uuid))
|
|
.bind(icon_url.as_str())
|
|
.execute(pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish())
|
|
}
|
|
|
|
self.icon = Some(icon_url.to_string());
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[derive(FromRow)]
|
|
struct RoleBuilder {
|
|
uuid: String,
|
|
guild_uuid: String,
|
|
name: String,
|
|
color: i64,
|
|
position: i32,
|
|
permissions: i64,
|
|
}
|
|
|
|
impl RoleBuilder {
|
|
fn build(&self) -> Role {
|
|
Role {
|
|
uuid: Uuid::from_str(&self.uuid).unwrap(),
|
|
guild_uuid: Uuid::from_str(&self.guild_uuid).unwrap(),
|
|
name: self.name.clone(),
|
|
color: self.color,
|
|
position: self.position,
|
|
permissions: self.permissions,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Clone)]
|
|
pub struct Role {
|
|
uuid: Uuid,
|
|
guild_uuid: Uuid,
|
|
name: String,
|
|
color: i64,
|
|
position: i32,
|
|
permissions: i64,
|
|
}
|
|
|
|
impl Role {
|
|
pub async fn fetch_all(
|
|
pool: &Pool<Postgres>,
|
|
guild_uuid: Uuid,
|
|
) -> Result<Vec<Self>, HttpResponse> {
|
|
let role_builders_result = sqlx::query_as(&format!("SELECT (uuid, guild_uuid, name, color, position, permissions) FROM roles WHERE guild_uuid = '{}'", guild_uuid))
|
|
.fetch_all(pool)
|
|
.await;
|
|
|
|
if let Err(error) = role_builders_result {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
let role_builders: Vec<RoleBuilder> = role_builders_result.unwrap();
|
|
|
|
Ok(role_builders.iter().map(|b| b.build()).collect())
|
|
}
|
|
|
|
pub async fn fetch_one(
|
|
pool: &Pool<Postgres>,
|
|
role_uuid: Uuid,
|
|
guild_uuid: Uuid,
|
|
) -> Result<Self, HttpResponse> {
|
|
let row = sqlx::query_as(&format!("SELECT (name, color, position, permissions) FROM roles WHERE guild_uuid = '{}' AND uuid = '{}'", guild_uuid, role_uuid))
|
|
.fetch_one(pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
let (name, color, position, permissions) = row.unwrap();
|
|
|
|
Ok(Role {
|
|
uuid: role_uuid,
|
|
guild_uuid,
|
|
name,
|
|
color,
|
|
position,
|
|
permissions,
|
|
})
|
|
}
|
|
|
|
pub async fn new(
|
|
pool: &Pool<Postgres>,
|
|
guild_uuid: Uuid,
|
|
name: String,
|
|
) -> Result<Self, HttpResponse> {
|
|
let role_uuid = Uuid::now_v7();
|
|
|
|
let row = sqlx::query(&format!(
|
|
"INSERT INTO channels (uuid, guild_uuid, name, position) VALUES ('{}', '{}', $1, $2)",
|
|
role_uuid, guild_uuid
|
|
))
|
|
.bind(&name)
|
|
.bind(0)
|
|
.execute(pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
let role = Self {
|
|
uuid: role_uuid,
|
|
guild_uuid,
|
|
name,
|
|
color: 16777215,
|
|
position: 0,
|
|
permissions: 0,
|
|
};
|
|
|
|
Ok(role)
|
|
}
|
|
}
|
|
|
|
pub struct Member {
|
|
pub uuid: Uuid,
|
|
pub nickname: Option<String>,
|
|
pub user_uuid: Uuid,
|
|
pub guild_uuid: Uuid,
|
|
}
|
|
|
|
impl Member {
|
|
async fn count(pool: &Pool<Postgres>, guild_uuid: Uuid) -> Result<i64, HttpResponse> {
|
|
let member_count = sqlx::query_scalar(&format!(
|
|
"SELECT COUNT(uuid) FROM guild_members WHERE guild_uuid = '{}'",
|
|
guild_uuid
|
|
))
|
|
.fetch_one(pool)
|
|
.await;
|
|
|
|
if let Err(error) = member_count {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
Ok(member_count.unwrap())
|
|
}
|
|
|
|
pub async fn fetch_one(
|
|
pool: &Pool<Postgres>,
|
|
user_uuid: Uuid,
|
|
guild_uuid: Uuid,
|
|
) -> Result<Self, HttpResponse> {
|
|
let row = sqlx::query_as(&format!("SELECT CAST(uuid AS VARCHAR), nickname FROM guild_members WHERE guild_uuid = '{}' AND user_uuid = '{}'", guild_uuid, user_uuid))
|
|
.fetch_one(pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
let (uuid, nickname): (String, Option<String>) = row.unwrap();
|
|
|
|
Ok(Self {
|
|
uuid: Uuid::from_str(&uuid).unwrap(),
|
|
nickname,
|
|
user_uuid,
|
|
guild_uuid,
|
|
})
|
|
}
|
|
|
|
pub async fn new(
|
|
pool: &Pool<Postgres>,
|
|
user_uuid: Uuid,
|
|
guild_uuid: Uuid,
|
|
) -> Result<Self, HttpResponse> {
|
|
let member_uuid = Uuid::now_v7();
|
|
|
|
let row = sqlx::query(&format!(
|
|
"INSERT INTO guild_members uuid, guild_uuid, user_uuid VALUES ('{}', '{}', '{}')",
|
|
member_uuid, guild_uuid, user_uuid
|
|
))
|
|
.execute(pool)
|
|
.await;
|
|
|
|
if let Err(error) = row {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
Ok(Self {
|
|
uuid: member_uuid,
|
|
nickname: None,
|
|
user_uuid,
|
|
guild_uuid,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[derive(FromRow)]
|
|
struct MessageBuilder {
|
|
uuid: String,
|
|
channel_uuid: String,
|
|
user_uuid: String,
|
|
message: String,
|
|
}
|
|
|
|
impl MessageBuilder {
|
|
fn build(&self) -> Message {
|
|
Message {
|
|
uuid: Uuid::from_str(&self.uuid).unwrap(),
|
|
channel_uuid: Uuid::from_str(&self.channel_uuid).unwrap(),
|
|
user_uuid: Uuid::from_str(&self.user_uuid).unwrap(),
|
|
message: self.message.clone(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
pub struct Message {
|
|
uuid: Uuid,
|
|
channel_uuid: Uuid,
|
|
user_uuid: Uuid,
|
|
message: String,
|
|
}
|
|
|
|
#[derive(FromRow)]
|
|
struct InviteBuilder {
|
|
id: String,
|
|
user_uuid: String,
|
|
guild_uuid: String,
|
|
}
|
|
|
|
impl InviteBuilder {
|
|
fn build(&self) -> Invite {
|
|
Invite {
|
|
id: self.id.clone(),
|
|
user_uuid: Uuid::from_str(&self.user_uuid).unwrap(),
|
|
guild_uuid: Uuid::from_str(&self.guild_uuid).unwrap(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Server invite struct
|
|
#[derive(Serialize)]
|
|
pub struct Invite {
|
|
/// case-sensitive alphanumeric string with a fixed length of 8 characters, can be up to 32 characters for custom invites
|
|
id: String,
|
|
/// User that created the invite
|
|
user_uuid: Uuid,
|
|
/// UUID of the guild that the invite belongs to
|
|
pub guild_uuid: Uuid,
|
|
}
|
|
|
|
impl Invite {
|
|
pub async fn fetch_one(pool: &Pool<Postgres>, invite_id: String) -> Result<Self, HttpResponse> {
|
|
let invite: Result<InviteBuilder, sqlx::Error> =
|
|
sqlx::query_as("SELECT id, user_uuid, guild_uuid FROM invites WHERE id = $1")
|
|
.bind(invite_id)
|
|
.fetch_one(pool)
|
|
.await;
|
|
|
|
if let Err(error) = invite {
|
|
error!("{}", error);
|
|
|
|
return Err(HttpResponse::InternalServerError().finish());
|
|
}
|
|
|
|
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())
|
|
}
|
|
}
|