1168 lines
38 KiB
Rust
1168 lines
38 KiB
Rust
use actix_web::web::BytesMut;
|
|
use chrono::Utc;
|
|
use diesel::{
|
|
delete, dsl::now, insert_into, prelude::{Insertable, Queryable}, update, ExpressionMethods, QueryDsl, Selectable, SelectableHelper
|
|
};
|
|
use diesel_async::{RunQueryDsl, pooled_connection::AsyncDieselConnectionManager};
|
|
use lettre::{message::{Mailbox, MessageBuilder as EmailBuilder, MultiPart}, transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncTransport, Message as Email, Tokio1Executor};
|
|
use log::debug;
|
|
use serde::{Deserialize, Serialize};
|
|
use tokio::task;
|
|
use url::Url;
|
|
use uuid::Uuid;
|
|
use argon2::{
|
|
PasswordHasher,
|
|
password_hash::{SaltString, rand_core::OsRng},
|
|
};
|
|
|
|
use crate::{
|
|
error::Error, schema::*, utils::{generate_refresh_token, global_checks, image_check, order_by_is_above, user_uuid_from_identifier, EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX}, Conn, Data
|
|
};
|
|
|
|
pub trait HasUuid {
|
|
fn uuid(&self) -> &Uuid;
|
|
}
|
|
|
|
pub trait HasIsAbove {
|
|
fn is_above(&self) -> Option<&Uuid>;
|
|
}
|
|
|
|
fn load_or_empty<T>(
|
|
query_result: Result<Vec<T>, diesel::result::Error>,
|
|
) -> Result<Vec<T>, diesel::result::Error> {
|
|
match query_result {
|
|
Ok(vec) => Ok(vec),
|
|
Err(diesel::result::Error::NotFound) => Ok(Vec::new()),
|
|
Err(e) => Err(e),
|
|
}
|
|
}
|
|
|
|
#[derive(PartialEq, Eq, Clone)]
|
|
pub enum MailTls {
|
|
StartTls,
|
|
Tls,
|
|
}
|
|
|
|
impl From<String> for MailTls {
|
|
fn from(value: String) -> Self {
|
|
match &*value.to_lowercase() {
|
|
"starttls" => Self::StartTls,
|
|
_ => Self::Tls,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct MailClient {
|
|
creds: Credentials,
|
|
smtp_server: String,
|
|
mbox: Mailbox,
|
|
tls: MailTls,
|
|
}
|
|
|
|
impl MailClient {
|
|
pub fn new<T: Into<MailTls>>(creds: Credentials, smtp_server: String, mbox: String, tls: T) -> Result<Self, Error> {
|
|
Ok(Self {
|
|
creds,
|
|
smtp_server,
|
|
mbox: mbox.parse()?,
|
|
tls: tls.into(),
|
|
})
|
|
}
|
|
|
|
pub fn message_builder(&self) -> EmailBuilder {
|
|
Email::builder()
|
|
.from(self.mbox.clone())
|
|
}
|
|
|
|
pub async fn send_mail(&self, email: Email) -> Result<(), Error> {
|
|
let mailer: AsyncSmtpTransport<Tokio1Executor> = match self.tls {
|
|
MailTls::StartTls => AsyncSmtpTransport::<Tokio1Executor>::starttls_relay(&self.smtp_server)?
|
|
.credentials(self.creds.clone())
|
|
.build(),
|
|
MailTls::Tls => AsyncSmtpTransport::<Tokio1Executor>::relay(&self.smtp_server)?
|
|
.credentials(self.creds.clone())
|
|
.build(),
|
|
};
|
|
|
|
let response = mailer.send(email).await?;
|
|
|
|
debug!("mail sending response: {:?}", response);
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[derive(Queryable, Selectable, Insertable, Clone, Debug)]
|
|
#[diesel(table_name = channels)]
|
|
#[diesel(check_for_backend(diesel::pg::Pg))]
|
|
struct ChannelBuilder {
|
|
uuid: Uuid,
|
|
guild_uuid: Uuid,
|
|
name: String,
|
|
description: Option<String>,
|
|
is_above: Option<Uuid>,
|
|
}
|
|
|
|
impl ChannelBuilder {
|
|
async fn build(self, conn: &mut Conn) -> Result<Channel, Error> {
|
|
use self::channel_permissions::dsl::*;
|
|
let channel_permission: Vec<ChannelPermission> = load_or_empty(
|
|
channel_permissions
|
|
.filter(channel_uuid.eq(self.uuid))
|
|
.select(ChannelPermission::as_select())
|
|
.load(conn)
|
|
.await,
|
|
)?;
|
|
|
|
Ok(Channel {
|
|
uuid: self.uuid,
|
|
guild_uuid: self.guild_uuid,
|
|
name: self.name,
|
|
description: self.description,
|
|
is_above: self.is_above,
|
|
permissions: channel_permission,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Clone, Debug)]
|
|
pub struct Channel {
|
|
pub uuid: Uuid,
|
|
pub guild_uuid: Uuid,
|
|
name: String,
|
|
description: Option<String>,
|
|
pub is_above: Option<Uuid>,
|
|
pub permissions: Vec<ChannelPermission>,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Clone, Queryable, Selectable, Debug)]
|
|
#[diesel(table_name = channel_permissions)]
|
|
#[diesel(check_for_backend(diesel::pg::Pg))]
|
|
pub struct ChannelPermission {
|
|
pub role_uuid: Uuid,
|
|
pub permissions: i64,
|
|
}
|
|
|
|
impl HasUuid for Channel {
|
|
fn uuid(&self) -> &Uuid {
|
|
self.uuid.as_ref()
|
|
}
|
|
}
|
|
|
|
impl HasIsAbove for Channel {
|
|
fn is_above(&self) -> Option<&Uuid> {
|
|
self.is_above.as_ref()
|
|
}
|
|
}
|
|
|
|
impl Channel {
|
|
pub async fn fetch_all(
|
|
pool: &deadpool::managed::Pool<
|
|
AsyncDieselConnectionManager<diesel_async::AsyncPgConnection>,
|
|
Conn,
|
|
>,
|
|
guild_uuid: Uuid,
|
|
) -> Result<Vec<Self>, Error> {
|
|
let mut conn = pool.get().await?;
|
|
|
|
use channels::dsl;
|
|
let channel_builders: Vec<ChannelBuilder> = load_or_empty(
|
|
dsl::channels
|
|
.filter(dsl::guild_uuid.eq(guild_uuid))
|
|
.select(ChannelBuilder::as_select())
|
|
.load(&mut conn)
|
|
.await,
|
|
)?;
|
|
|
|
let channel_futures = channel_builders.iter().map(async move |c| {
|
|
let mut conn = pool.get().await?;
|
|
c.clone().build(&mut conn).await
|
|
});
|
|
|
|
futures::future::try_join_all(channel_futures).await
|
|
}
|
|
|
|
pub async fn fetch_one(conn: &mut Conn, channel_uuid: Uuid) -> Result<Self, Error> {
|
|
use channels::dsl;
|
|
let channel_builder: ChannelBuilder = dsl::channels
|
|
.filter(dsl::uuid.eq(channel_uuid))
|
|
.select(ChannelBuilder::as_select())
|
|
.get_result(conn)
|
|
.await?;
|
|
|
|
channel_builder.build(conn).await
|
|
}
|
|
|
|
pub async fn new(
|
|
data: actix_web::web::Data<Data>,
|
|
guild_uuid: Uuid,
|
|
name: String,
|
|
description: Option<String>,
|
|
) -> Result<Self, Error> {
|
|
let mut conn = data.pool.get().await?;
|
|
|
|
let channel_uuid = Uuid::now_v7();
|
|
|
|
let channels = Self::fetch_all(&data.pool, guild_uuid).await?;
|
|
|
|
let channels_ordered = order_by_is_above(channels).await?;
|
|
|
|
let last_channel = channels_ordered.last();
|
|
|
|
let new_channel = ChannelBuilder {
|
|
uuid: channel_uuid,
|
|
guild_uuid,
|
|
name: name.clone(),
|
|
description: description.clone(),
|
|
is_above: None,
|
|
};
|
|
|
|
insert_into(channels::table)
|
|
.values(new_channel.clone())
|
|
.execute(&mut conn)
|
|
.await?;
|
|
|
|
if let Some(old_last_channel) = last_channel {
|
|
use channels::dsl;
|
|
update(channels::table)
|
|
.filter(dsl::uuid.eq(old_last_channel.uuid))
|
|
.set(dsl::is_above.eq(new_channel.uuid))
|
|
.execute(&mut conn)
|
|
.await?;
|
|
}
|
|
|
|
// returns different object because there's no reason to build the channelbuilder (wastes 1 database request)
|
|
let channel = Self {
|
|
uuid: channel_uuid,
|
|
guild_uuid,
|
|
name,
|
|
description,
|
|
is_above: None,
|
|
permissions: vec![],
|
|
};
|
|
|
|
data.set_cache_key(channel_uuid.to_string(), channel.clone(), 1800)
|
|
.await?;
|
|
|
|
data.del_cache_key(format!("{}_channels", guild_uuid))
|
|
.await?;
|
|
|
|
Ok(channel)
|
|
}
|
|
|
|
pub async fn delete(self, conn: &mut Conn) -> Result<(), Error> {
|
|
use channels::dsl;
|
|
delete(channels::table)
|
|
.filter(dsl::uuid.eq(self.uuid))
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn fetch_messages(
|
|
&self,
|
|
data: &Data,
|
|
amount: i64,
|
|
offset: i64,
|
|
) -> Result<Vec<Message>, Error> {
|
|
let mut conn = data.pool.get().await?;
|
|
|
|
use messages::dsl;
|
|
let messages: Vec<MessageBuilder> = load_or_empty(
|
|
dsl::messages
|
|
.filter(dsl::channel_uuid.eq(self.uuid))
|
|
.select(MessageBuilder::as_select())
|
|
.order(dsl::uuid.desc())
|
|
.limit(amount)
|
|
.offset(offset)
|
|
.load(&mut conn)
|
|
.await,
|
|
)?;
|
|
|
|
let message_futures = messages.iter().map(async move |b| {
|
|
b.build(data).await
|
|
});
|
|
|
|
futures::future::try_join_all(message_futures).await
|
|
}
|
|
|
|
pub async fn new_message(
|
|
&self,
|
|
data: &Data,
|
|
user_uuid: Uuid,
|
|
message: String,
|
|
) -> Result<Message, Error> {
|
|
let message_uuid = Uuid::now_v7();
|
|
|
|
let message = MessageBuilder {
|
|
uuid: message_uuid,
|
|
channel_uuid: self.uuid,
|
|
user_uuid,
|
|
message,
|
|
};
|
|
|
|
let mut conn = data.pool.get().await?;
|
|
|
|
insert_into(messages::table)
|
|
.values(message.clone())
|
|
.execute(&mut conn)
|
|
.await?;
|
|
|
|
message.build(data).await
|
|
}
|
|
}
|
|
|
|
#[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, Queryable, Selectable, Insertable, Clone)]
|
|
#[diesel(table_name = guilds)]
|
|
#[diesel(check_for_backend(diesel::pg::Pg))]
|
|
struct GuildBuilder {
|
|
uuid: Uuid,
|
|
name: String,
|
|
description: Option<String>,
|
|
icon: Option<String>,
|
|
owner_uuid: Uuid,
|
|
}
|
|
|
|
impl GuildBuilder {
|
|
async fn build(self, conn: &mut Conn) -> Result<Guild, Error> {
|
|
let member_count = Member::count(conn, self.uuid).await?;
|
|
|
|
let roles = Role::fetch_all(conn, self.uuid).await?;
|
|
|
|
Ok(Guild {
|
|
uuid: self.uuid,
|
|
name: self.name,
|
|
description: self.description,
|
|
icon: self.icon.and_then(|i| i.parse().ok()),
|
|
owner_uuid: self.owner_uuid,
|
|
roles,
|
|
member_count,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
pub struct Guild {
|
|
pub uuid: Uuid,
|
|
name: String,
|
|
description: Option<String>,
|
|
icon: Option<Url>,
|
|
owner_uuid: Uuid,
|
|
pub roles: Vec<Role>,
|
|
member_count: i64,
|
|
}
|
|
|
|
impl Guild {
|
|
pub async fn fetch_one(conn: &mut Conn, guild_uuid: Uuid) -> Result<Self, Error> {
|
|
use guilds::dsl;
|
|
let guild_builder: GuildBuilder = dsl::guilds
|
|
.filter(dsl::uuid.eq(guild_uuid))
|
|
.select(GuildBuilder::as_select())
|
|
.get_result(conn)
|
|
.await?;
|
|
|
|
guild_builder.build(conn).await
|
|
}
|
|
|
|
pub async fn fetch_amount(
|
|
pool: &deadpool::managed::Pool<
|
|
AsyncDieselConnectionManager<diesel_async::AsyncPgConnection>,
|
|
Conn,
|
|
>,
|
|
offset: i64,
|
|
amount: i64,
|
|
) -> Result<Vec<Self>, Error> {
|
|
// Fetch guild data from database
|
|
let mut conn = pool.get().await?;
|
|
|
|
use guilds::dsl;
|
|
let guild_builders: Vec<GuildBuilder> = load_or_empty(
|
|
dsl::guilds
|
|
.select(GuildBuilder::as_select())
|
|
.order_by(dsl::uuid)
|
|
.offset(offset)
|
|
.limit(amount)
|
|
.load(&mut conn)
|
|
.await,
|
|
)?;
|
|
|
|
// Process each guild concurrently
|
|
let guild_futures = guild_builders.iter().map(async move |g| {
|
|
let mut conn = pool.get().await?;
|
|
g.clone().build(&mut conn).await
|
|
});
|
|
|
|
// Execute all futures concurrently and collect results
|
|
futures::future::try_join_all(guild_futures).await
|
|
}
|
|
|
|
pub async fn new(conn: &mut Conn, name: String, owner_uuid: Uuid) -> Result<Self, Error> {
|
|
let guild_uuid = Uuid::now_v7();
|
|
|
|
let guild_builder = GuildBuilder {
|
|
uuid: guild_uuid,
|
|
name: name.clone(),
|
|
description: None,
|
|
icon: None,
|
|
owner_uuid,
|
|
};
|
|
|
|
insert_into(guilds::table)
|
|
.values(guild_builder)
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
let member_uuid = Uuid::now_v7();
|
|
|
|
let member = Member {
|
|
uuid: member_uuid,
|
|
nickname: None,
|
|
user_uuid: owner_uuid,
|
|
guild_uuid,
|
|
};
|
|
|
|
insert_into(guild_members::table)
|
|
.values(member)
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
Ok(Guild {
|
|
uuid: guild_uuid,
|
|
name,
|
|
description: None,
|
|
icon: None,
|
|
owner_uuid,
|
|
roles: vec![],
|
|
member_count: 1,
|
|
})
|
|
}
|
|
|
|
pub async fn get_invites(&self, conn: &mut Conn) -> Result<Vec<Invite>, Error> {
|
|
use invites::dsl;
|
|
let invites = load_or_empty(
|
|
dsl::invites
|
|
.filter(dsl::guild_uuid.eq(self.uuid))
|
|
.select(Invite::as_select())
|
|
.load(conn)
|
|
.await,
|
|
)?;
|
|
|
|
Ok(invites)
|
|
}
|
|
|
|
pub async fn create_invite(
|
|
&self,
|
|
conn: &mut Conn,
|
|
member: &Member,
|
|
custom_id: Option<String>,
|
|
) -> Result<Invite, Error> {
|
|
let invite_id;
|
|
|
|
if let Some(id) = custom_id {
|
|
invite_id = id;
|
|
if invite_id.len() > 32 {
|
|
return Err(Error::BadRequest("MAX LENGTH".to_string()));
|
|
}
|
|
} else {
|
|
let charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
|
|
|
|
invite_id = random_string::generate(8, charset);
|
|
}
|
|
|
|
let invite = Invite {
|
|
id: invite_id,
|
|
user_uuid: member.user_uuid,
|
|
guild_uuid: self.uuid,
|
|
};
|
|
|
|
insert_into(invites::table)
|
|
.values(invite.clone())
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
Ok(invite)
|
|
}
|
|
|
|
// FIXME: Horrible security
|
|
pub async fn set_icon(
|
|
&mut self,
|
|
bunny_cdn: &bunny_api_tokio::Client,
|
|
conn: &mut Conn,
|
|
cdn_url: Url,
|
|
icon: BytesMut,
|
|
) -> Result<(), Error> {
|
|
let icon_clone = icon.clone();
|
|
let image_type = task::spawn_blocking(move || image_check(icon_clone)).await??;
|
|
|
|
if let Some(icon) = &self.icon {
|
|
let relative_url = icon.path().trim_start_matches('/');
|
|
|
|
bunny_cdn.storage.delete(relative_url).await?;
|
|
}
|
|
|
|
let path = format!("icons/{}/icon.{}", self.uuid, image_type);
|
|
|
|
bunny_cdn.storage.upload(path.clone(), icon.into()).await?;
|
|
|
|
let icon_url = cdn_url.join(&path)?;
|
|
|
|
use guilds::dsl;
|
|
update(guilds::table)
|
|
.filter(dsl::uuid.eq(self.uuid))
|
|
.set(dsl::icon.eq(icon_url.as_str()))
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
self.icon = Some(icon_url);
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Clone, Queryable, Selectable, Insertable)]
|
|
#[diesel(table_name = roles)]
|
|
#[diesel(check_for_backend(diesel::pg::Pg))]
|
|
pub struct Role {
|
|
uuid: Uuid,
|
|
guild_uuid: Uuid,
|
|
name: String,
|
|
color: i32,
|
|
is_above: Option<Uuid>,
|
|
permissions: i64,
|
|
}
|
|
|
|
impl HasUuid for Role {
|
|
fn uuid(&self) -> &Uuid {
|
|
self.uuid.as_ref()
|
|
}
|
|
}
|
|
|
|
impl HasIsAbove for Role {
|
|
fn is_above(&self) -> Option<&Uuid> {
|
|
self.is_above.as_ref()
|
|
}
|
|
}
|
|
|
|
impl Role {
|
|
pub async fn fetch_all(conn: &mut Conn, guild_uuid: Uuid) -> Result<Vec<Self>, Error> {
|
|
use roles::dsl;
|
|
let roles: Vec<Role> = load_or_empty(
|
|
dsl::roles
|
|
.filter(dsl::guild_uuid.eq(guild_uuid))
|
|
.select(Role::as_select())
|
|
.load(conn)
|
|
.await,
|
|
)?;
|
|
|
|
Ok(roles)
|
|
}
|
|
|
|
pub async fn fetch_one(conn: &mut Conn, role_uuid: Uuid) -> Result<Self, Error> {
|
|
use roles::dsl;
|
|
let role: Role = dsl::roles
|
|
.filter(dsl::uuid.eq(role_uuid))
|
|
.select(Role::as_select())
|
|
.get_result(conn)
|
|
.await?;
|
|
|
|
Ok(role)
|
|
}
|
|
|
|
pub async fn new(conn: &mut Conn, guild_uuid: Uuid, name: String) -> Result<Self, Error> {
|
|
let role_uuid = Uuid::now_v7();
|
|
|
|
let roles = Self::fetch_all(conn, guild_uuid).await?;
|
|
|
|
let roles_ordered = order_by_is_above(roles).await?;
|
|
|
|
let last_role = roles_ordered.last();
|
|
|
|
let new_role = Role {
|
|
uuid: role_uuid,
|
|
guild_uuid,
|
|
name,
|
|
color: 16777215,
|
|
is_above: None,
|
|
permissions: 0,
|
|
};
|
|
|
|
insert_into(roles::table)
|
|
.values(new_role.clone())
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
if let Some(old_last_role) = last_role {
|
|
use roles::dsl;
|
|
update(roles::table)
|
|
.filter(dsl::uuid.eq(old_last_role.uuid))
|
|
.set(dsl::is_above.eq(new_role.uuid))
|
|
.execute(conn)
|
|
.await?;
|
|
}
|
|
|
|
Ok(new_role)
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Queryable, Selectable, Insertable)]
|
|
#[diesel(table_name = guild_members)]
|
|
#[diesel(check_for_backend(diesel::pg::Pg))]
|
|
pub struct Member {
|
|
pub uuid: Uuid,
|
|
pub nickname: Option<String>,
|
|
pub user_uuid: Uuid,
|
|
pub guild_uuid: Uuid,
|
|
}
|
|
|
|
impl Member {
|
|
async fn count(conn: &mut Conn, guild_uuid: Uuid) -> Result<i64, Error> {
|
|
use guild_members::dsl;
|
|
let count: i64 = dsl::guild_members
|
|
.filter(dsl::guild_uuid.eq(guild_uuid))
|
|
.count()
|
|
.get_result(conn)
|
|
.await?;
|
|
|
|
Ok(count)
|
|
}
|
|
|
|
pub async fn fetch_one(
|
|
conn: &mut Conn,
|
|
user_uuid: Uuid,
|
|
guild_uuid: Uuid,
|
|
) -> Result<Self, Error> {
|
|
use guild_members::dsl;
|
|
let member: Member = dsl::guild_members
|
|
.filter(dsl::user_uuid.eq(user_uuid))
|
|
.filter(dsl::guild_uuid.eq(guild_uuid))
|
|
.select(Member::as_select())
|
|
.get_result(conn)
|
|
.await?;
|
|
|
|
Ok(member)
|
|
}
|
|
|
|
pub async fn new(conn: &mut Conn, user_uuid: Uuid, guild_uuid: Uuid) -> Result<Self, Error> {
|
|
let member_uuid = Uuid::now_v7();
|
|
|
|
let member = Member {
|
|
uuid: member_uuid,
|
|
guild_uuid,
|
|
user_uuid,
|
|
nickname: None,
|
|
};
|
|
|
|
insert_into(guild_members::table)
|
|
.values(member)
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
Ok(Self {
|
|
uuid: member_uuid,
|
|
nickname: None,
|
|
user_uuid,
|
|
guild_uuid,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Queryable, Selectable, Insertable)]
|
|
#[diesel(table_name = messages)]
|
|
#[diesel(check_for_backend(diesel::pg::Pg))]
|
|
pub struct MessageBuilder {
|
|
uuid: Uuid,
|
|
channel_uuid: Uuid,
|
|
user_uuid: Uuid,
|
|
message: String,
|
|
}
|
|
|
|
impl MessageBuilder {
|
|
pub async fn build(&self, data: &Data) -> Result<Message, Error> {
|
|
let user = User::fetch_one(data, self.user_uuid).await?;
|
|
|
|
Ok(Message {
|
|
uuid: self.uuid,
|
|
channel_uuid: self.channel_uuid,
|
|
user_uuid: self.user_uuid,
|
|
message: self.message.clone(),
|
|
user,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Serialize)]
|
|
pub struct Message {
|
|
uuid: Uuid,
|
|
channel_uuid: Uuid,
|
|
user_uuid: Uuid,
|
|
message: String,
|
|
user: User,
|
|
}
|
|
|
|
/// Server invite struct
|
|
#[derive(Clone, Serialize, Queryable, Selectable, Insertable)]
|
|
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(conn: &mut Conn, invite_id: String) -> Result<Self, Error> {
|
|
use invites::dsl;
|
|
let invite: Invite = dsl::invites
|
|
.filter(dsl::id.eq(invite_id))
|
|
.select(Invite::as_select())
|
|
.get_result(conn)
|
|
.await?;
|
|
|
|
Ok(invite)
|
|
}
|
|
}
|
|
|
|
#[derive(Deserialize, Serialize, Clone, Queryable, Selectable)]
|
|
#[diesel(table_name = users)]
|
|
#[diesel(check_for_backend(diesel::pg::Pg))]
|
|
pub struct User {
|
|
uuid: Uuid,
|
|
username: String,
|
|
display_name: Option<String>,
|
|
avatar: Option<String>,
|
|
}
|
|
|
|
impl User {
|
|
pub async fn fetch_one(data: &Data, user_uuid: Uuid) -> Result<Self, Error> {
|
|
let mut conn = data.pool.get().await?;
|
|
|
|
if let Ok(cache_hit) = data.get_cache_key(user_uuid.to_string()).await {
|
|
return Ok(serde_json::from_str(&cache_hit)?);
|
|
}
|
|
|
|
use users::dsl;
|
|
let user: User = dsl::users
|
|
.filter(dsl::uuid.eq(user_uuid))
|
|
.select(User::as_select())
|
|
.get_result(&mut conn)
|
|
.await?;
|
|
|
|
data.set_cache_key(user_uuid.to_string(), user.clone(), 1800)
|
|
.await?;
|
|
|
|
Ok(user)
|
|
}
|
|
|
|
pub async fn fetch_amount(
|
|
conn: &mut Conn,
|
|
offset: i64,
|
|
amount: i64,
|
|
) -> Result<Vec<Self>, Error> {
|
|
use users::dsl;
|
|
let users: Vec<User> = load_or_empty(
|
|
dsl::users
|
|
.limit(amount)
|
|
.offset(offset)
|
|
.select(User::as_select())
|
|
.load(conn)
|
|
.await,
|
|
)?;
|
|
|
|
Ok(users)
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Queryable, Selectable)]
|
|
#[diesel(table_name = users)]
|
|
#[diesel(check_for_backend(diesel::pg::Pg))]
|
|
pub struct Me {
|
|
pub uuid: Uuid,
|
|
username: String,
|
|
display_name: Option<String>,
|
|
avatar: Option<String>,
|
|
email: String,
|
|
pub email_verified: bool,
|
|
}
|
|
|
|
impl Me {
|
|
pub async fn get(conn: &mut Conn, user_uuid: Uuid) -> Result<Self, Error> {
|
|
use users::dsl;
|
|
let me: Me = dsl::users
|
|
.filter(dsl::uuid.eq(user_uuid))
|
|
.select(Me::as_select())
|
|
.get_result(conn)
|
|
.await?;
|
|
|
|
Ok(me)
|
|
}
|
|
|
|
pub async fn fetch_memberships(&self, conn: &mut Conn) -> Result<Vec<Member>, Error> {
|
|
use guild_members::dsl;
|
|
let memberships: Vec<Member> = dsl::guild_members
|
|
.filter(dsl::user_uuid.eq(self.uuid))
|
|
.select(Member::as_select())
|
|
.load(conn)
|
|
.await?;
|
|
|
|
Ok(memberships)
|
|
}
|
|
|
|
pub async fn set_avatar(
|
|
&mut self,
|
|
bunny_cdn: &bunny_api_tokio::Client,
|
|
conn: &mut Conn,
|
|
cdn_url: Url,
|
|
avatar: BytesMut,
|
|
) -> Result<(), Error> {
|
|
let avatar_clone = avatar.clone();
|
|
let image_type = task::spawn_blocking(move || image_check(avatar_clone)).await??;
|
|
|
|
if let Some(avatar) = &self.avatar {
|
|
let avatar_url: Url = avatar.parse()?;
|
|
|
|
let relative_url = avatar_url.path().trim_start_matches('/');
|
|
|
|
bunny_cdn.storage.delete(relative_url).await?;
|
|
}
|
|
|
|
let path = format!("avatar/{}/avatar.{}", self.uuid, image_type);
|
|
|
|
bunny_cdn
|
|
.storage
|
|
.upload(path.clone(), avatar.into())
|
|
.await?;
|
|
|
|
let avatar_url = cdn_url.join(&path)?;
|
|
|
|
use users::dsl;
|
|
update(users::table)
|
|
.filter(dsl::uuid.eq(self.uuid))
|
|
.set(dsl::avatar.eq(avatar_url.as_str()))
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
self.avatar = Some(avatar_url.to_string());
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn verify_email(&self, conn: &mut Conn) -> Result<(), Error> {
|
|
use users::dsl;
|
|
update(users::table)
|
|
.filter(dsl::uuid.eq(self.uuid))
|
|
.set(dsl::email_verified.eq(true))
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn set_username(
|
|
&mut self,
|
|
conn: &mut Conn,
|
|
new_username: String,
|
|
) -> Result<(), Error> {
|
|
if !USERNAME_REGEX.is_match(&new_username) {
|
|
return Err(Error::BadRequest("Invalid username".to_string()));
|
|
}
|
|
|
|
use users::dsl;
|
|
update(users::table)
|
|
.filter(dsl::uuid.eq(self.uuid))
|
|
.set(dsl::username.eq(new_username.as_str()))
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
self.username = new_username;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn set_display_name(
|
|
&mut self,
|
|
conn: &mut Conn,
|
|
new_display_name: String,
|
|
) -> Result<(), Error> {
|
|
use users::dsl;
|
|
update(users::table)
|
|
.filter(dsl::uuid.eq(self.uuid))
|
|
.set(dsl::display_name.eq(new_display_name.as_str()))
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
self.display_name = Some(new_display_name);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn set_email(&mut self, conn: &mut Conn, new_email: String) -> Result<(), Error> {
|
|
if !EMAIL_REGEX.is_match(&new_email) {
|
|
return Err(Error::BadRequest("Invalid username".to_string()));
|
|
}
|
|
|
|
use users::dsl;
|
|
update(users::table)
|
|
.filter(dsl::uuid.eq(self.uuid))
|
|
.set((
|
|
dsl::email.eq(new_email.as_str()),
|
|
dsl::email_verified.eq(false),
|
|
))
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
self.email = new_email;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct StartAmountQuery {
|
|
pub start: Option<i64>,
|
|
pub amount: Option<i64>,
|
|
}
|
|
|
|
#[derive(Selectable, Queryable)]
|
|
#[diesel(table_name = email_tokens)]
|
|
#[diesel(check_for_backend(diesel::pg::Pg))]
|
|
pub struct EmailToken {
|
|
user_uuid: Uuid,
|
|
pub token: String,
|
|
pub created_at: chrono::DateTime<Utc>,
|
|
}
|
|
|
|
impl EmailToken {
|
|
pub async fn get(conn: &mut Conn, user_uuid: Uuid) -> Result<EmailToken, Error> {
|
|
use email_tokens::dsl;
|
|
let email_token = dsl::email_tokens
|
|
.filter(dsl::user_uuid.eq(user_uuid))
|
|
.select(EmailToken::as_select())
|
|
.get_result(conn)
|
|
.await?;
|
|
|
|
Ok(email_token)
|
|
}
|
|
|
|
pub async fn new(data: &Data, me: Me) -> Result<(), Error> {
|
|
let token = generate_refresh_token()?;
|
|
|
|
let mut conn = data.pool.get().await?;
|
|
|
|
use email_tokens::dsl;
|
|
insert_into(email_tokens::table)
|
|
.values((dsl::user_uuid.eq(me.uuid), dsl::token.eq(&token), dsl::created_at.eq(now)))
|
|
.execute(&mut conn)
|
|
.await?;
|
|
|
|
let mut verify_endpoint = data.config.web.url.join("verify-email")?;
|
|
|
|
verify_endpoint.set_query(Some(&format!("token={}", token)));
|
|
|
|
let email = data
|
|
.mail_client
|
|
.message_builder()
|
|
.to(me.email.parse()?)
|
|
.subject(format!("{} E-mail Verification", data.config.instance.name))
|
|
.multipart(MultiPart::alternative_plain_html(
|
|
format!("Verify your {} account\n\nHello, {}!\nThanks for creating a new account on Gorb.\nThe final step to create your account is to verify your email address by visiting the page, within 24 hours.\n\n{}\n\nIf you didn't ask to verify this address, you can safely ignore this email\n\nThanks, The gorb team.", data.config.instance.name, me.username, verify_endpoint),
|
|
format!(r#"<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><style>:root{{--header-text-colour: #ffffff;--footer-text-colour: #7f7f7f;--button-text-colour: #170e08;--text-colour: #170e08;--background-colour: #fbf6f2;--primary-colour: #df5f0b;--secondary-colour: #e8ac84;--accent-colour: #e68b4e;}}@media (prefers-color-scheme: dark){{:root{{--header-text-colour: #ffffff;--footer-text-colour: #585858;--button-text-colour: #ffffff;--text-colour: #f7eee8;--background-colour: #0c0704;--primary-colour: #f4741f;--secondary-colour: #7c4018;--accent-colour: #b35719;}}}}@media (max-width: 600px){{.container{{width: 100%;}}}}body{{font-family: Arial, sans-serif;align-content: center;text-align: center;margin: 0;padding: 0;background-color: var(--background-colour);color: var(--text-colour);width: 100%;max-width: 600px;margin: 0 auto;border-radius: 5px;}}.header{{background-color: var(--primary-colour);color: var(--header-text-colour);padding: 20px;}}.verify-button{{background-color: var(--accent-colour);color: var(--button-text-colour);padding: 12px 30px;margin: 16px;font-size: 20px;transition: background-color 0.3s;cursor: pointer;border: none;border-radius: 14px;text-decoration: none;display: inline-block;}}.verify-button:hover{{background-color: var(--secondary-colour);}}.content{{padding: 20px 30px;}}.footer{{padding: 10px;font-size: 12px;color: var(--footer-text-colour);}}</style></head><body><div class="container"><div class="header"><h1>Verify your {} Account</h1></div><div class="content"><h2>Hello, {}!</h2><p>Thanks for creating a new account on Gorb.</p><p>The final step to create your account is to verify your email address by clicking the button below, within 24 hours.</p><a href="{}" class="verify-button">VERIFY ACCOUNT</a><p>If you didn't ask to verify this address, you can safely ignore this email.</p><div class="footer"><p>Thanks<br>The gorb team.</p></div></div></div></body></html>"#, data.config.instance.name, me.username, verify_endpoint)
|
|
))?;
|
|
|
|
data
|
|
.mail_client
|
|
.send_mail(email)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn delete(&self, conn: &mut Conn) -> Result<(), Error> {
|
|
use email_tokens::dsl;
|
|
delete(email_tokens::table)
|
|
.filter(dsl::user_uuid.eq(self.user_uuid))
|
|
.filter(dsl::token.eq(&self.token))
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[derive(Selectable, Queryable)]
|
|
#[diesel(table_name = password_reset_tokens)]
|
|
#[diesel(check_for_backend(diesel::pg::Pg))]
|
|
pub struct PasswordResetToken {
|
|
user_uuid: Uuid,
|
|
pub token: String,
|
|
pub created_at: chrono::DateTime<Utc>,
|
|
}
|
|
|
|
impl PasswordResetToken {
|
|
pub async fn get(conn: &mut Conn, token: String) -> Result<PasswordResetToken, Error> {
|
|
use password_reset_tokens::dsl;
|
|
let password_reset_token = dsl::password_reset_tokens
|
|
.filter(dsl::token.eq(token))
|
|
.select(PasswordResetToken::as_select())
|
|
.get_result(conn)
|
|
.await?;
|
|
|
|
Ok(password_reset_token)
|
|
}
|
|
|
|
pub async fn get_with_identifier(conn: &mut Conn, identifier: String) -> Result<PasswordResetToken, Error> {
|
|
let user_uuid = user_uuid_from_identifier(conn, &identifier).await?;
|
|
|
|
use password_reset_tokens::dsl;
|
|
let password_reset_token = dsl::password_reset_tokens
|
|
.filter(dsl::user_uuid.eq(user_uuid))
|
|
.select(PasswordResetToken::as_select())
|
|
.get_result(conn)
|
|
.await?;
|
|
|
|
Ok(password_reset_token)
|
|
}
|
|
|
|
pub async fn new(data: &Data, identifier: String) -> Result<(), Error> {
|
|
let token = generate_refresh_token()?;
|
|
|
|
let mut conn = data.pool.get().await?;
|
|
|
|
let user_uuid = user_uuid_from_identifier(&mut conn, &identifier).await?;
|
|
|
|
global_checks(&data, user_uuid).await?;
|
|
|
|
use users::dsl as udsl;
|
|
let (username, email_address): (String, String) = udsl::users
|
|
.filter(udsl::uuid.eq(user_uuid))
|
|
.select((udsl::username, udsl::email))
|
|
.get_result(&mut conn)
|
|
.await?;
|
|
|
|
use password_reset_tokens::dsl;
|
|
insert_into(password_reset_tokens::table)
|
|
.values((dsl::user_uuid.eq(user_uuid), dsl::token.eq(&token), dsl::created_at.eq(now)))
|
|
.execute(&mut conn)
|
|
.await?;
|
|
|
|
let mut reset_endpoint = data.config.web.url.join("reset-password")?;
|
|
|
|
reset_endpoint.set_query(Some(&format!("token={}", token)));
|
|
|
|
let email = data
|
|
.mail_client
|
|
.message_builder()
|
|
.to(email_address.parse()?)
|
|
.subject(format!("{} Password Reset", data.config.instance.name))
|
|
.multipart(MultiPart::alternative_plain_html(
|
|
format!("{} Password Reset\n\nHello, {}!\nSomeone requested a password reset for your Gorb account.\nClick the button below within 24 hours to reset your password.\n\n{}\n\nIf you didn't request a password reset, don't worry, your account is safe and you can safely ignore this email.\n\nThanks, The gorb team.", data.config.instance.name, username, reset_endpoint),
|
|
format!(r#"<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><style>:root {{--header-text-colour: #ffffff;--footer-text-colour: #7f7f7f;--button-text-colour: #170e08;--text-colour: #170e08;--background-colour: #fbf6f2;--primary-colour: #df5f0b;--secondary-colour: #e8ac84;--accent-colour: #e68b4e;}}@media (prefers-color-scheme: dark) {{:root {{--header-text-colour: #ffffff;--footer-text-colour: #585858;--button-text-colour: #ffffff;--text-colour: #f7eee8;--background-colour: #0c0704;--primary-colour: #f4741f;--secondary-colour: #7c4018;--accent-colour: #b35719;}}}}@media (max-width: 600px) {{.container {{width: 100%;}}}}body {{font-family: Arial, sans-serif;align-content: center;text-align: center;margin: 0;padding: 0;background-color: var(--background-colour);color: var(--text-colour);width: 100%;max-width: 600px;margin: 0 auto;border-radius: 5px;}}.header {{background-color: var(--primary-colour);color: var(--header-text-colour);padding: 20px;}}.verify-button {{background-color: var(--accent-colour);color: var(--button-text-colour);padding: 12px 30px;margin: 16px;font-size: 20px;transition: background-color 0.3s;cursor: pointer;border: none;border-radius: 14px;text-decoration: none;display: inline-block;}}.verify-button:hover {{background-color: var(--secondary-colour);}}.content {{padding: 20px 30px;}}.footer {{padding: 10px;font-size: 12px;color: var(--footer-text-colour);}}</style></head><body><div class="container"><div class="header"><h1>{} Password Reset</h1></div><div class="content"><h2>Hello, {}!</h2><p>Someone requested a password reset for your Gorb account.</p><p>Click the button below within 24 hours to reset your password.</p><a href="{}" class="verify-button">RESET PASSWORD</a><p>If you didn't request a password reset, don't worry, your account is safe and you can safely ignore this email.</p><div class="footer"><p>Thanks<br>The gorb team.</p></div></div></div></body></html>"#, data.config.instance.name, username, reset_endpoint)
|
|
))?;
|
|
|
|
data
|
|
.mail_client
|
|
.send_mail(email)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn set_password(&self, data: &Data, password: String) -> Result<(), Error> {
|
|
if !PASSWORD_REGEX.is_match(&password) {
|
|
return Err(Error::BadRequest("Please provide a valid password".to_string()))
|
|
}
|
|
|
|
let salt = SaltString::generate(&mut OsRng);
|
|
|
|
let hashed_password = data
|
|
.argon2
|
|
.hash_password(password.as_bytes(), &salt)
|
|
.map_err(|e| Error::PasswordHashError(e.to_string()))?;
|
|
|
|
let mut conn = data.pool.get().await?;
|
|
|
|
use users::dsl;
|
|
update(users::table)
|
|
.filter(dsl::uuid.eq(self.user_uuid))
|
|
.set(dsl::password.eq(hashed_password.to_string()))
|
|
.execute(&mut conn)
|
|
.await?;
|
|
|
|
let (username, email_address): (String, String) = dsl::users
|
|
.filter(dsl::uuid.eq(self.user_uuid))
|
|
.select((dsl::username, dsl::email))
|
|
.get_result(&mut conn)
|
|
.await?;
|
|
|
|
let login_page = data.config.web.url.join("login")?;
|
|
|
|
let email = data
|
|
.mail_client
|
|
.message_builder()
|
|
.to(email_address.parse()?)
|
|
.subject(format!("Your {} Password has been Reset", data.config.instance.name))
|
|
.multipart(MultiPart::alternative_plain_html(
|
|
format!("{} Password Reset Confirmation\n\nHello, {}!\nYour password has been successfully reset for your Gorb account.\nIf you did not initiate this change, please click the link below to reset your password <strong>immediately</strong>.\n\n{}\n\nThanks, The gorb team.", data.config.instance.name, username, login_page),
|
|
format!(r#"<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><style>:root {{--header-text-colour: #ffffff;--footer-text-colour: #7f7f7f;--button-text-colour: #170e08;--text-colour: #170e08;--background-colour: #fbf6f2;--primary-colour: #df5f0b;--secondary-colour: #e8ac84;--accent-colour: #e68b4e;}}@media (prefers-color-scheme: dark) {{:root {{--header-text-colour: #ffffff;--footer-text-colour: #585858;--button-text-colour: #ffffff;--text-colour: #f7eee8;--background-colour: #0c0704;--primary-colour: #f4741f;--secondary-colour: #7c4018;--accent-colour: #b35719;}}}}@media (max-width: 600px) {{.container {{width: 100%;}}}}body {{font-family: Arial, sans-serif;align-content: center;text-align: center;margin: 0;padding: 0;background-color: var(--background-colour);color: var(--text-colour);width: 100%;max-width: 600px;margin: 0 auto;border-radius: 5px;}}.header {{background-color: var(--primary-colour);color: var(--header-text-colour);padding: 20px;}}.verify-button {{background-color: var(--accent-colour);color: var(--button-text-colour);padding: 12px 30px;margin: 16px;font-size: 20px;transition: background-color 0.3s;cursor: pointer;border: none;border-radius: 14px;text-decoration: none;display: inline-block;}}.verify-button:hover {{background-color: var(--secondary-colour);}}.content {{padding: 20px 30px;}}.footer {{padding: 10px;font-size: 12px;color: var(--footer-text-colour);}}</style></head><body><div class="container"><div class="header"><h1>{} Password Reset Confirmation</h1></div><div class="content"><h2>Hello, {}!</h2><p>Your password has been successfully reset for your Gorb account.</p><p>If you did not initiate this change, please click the button below to reset your password <strong>immediately</strong>.</p><a href="{}" class="verify-button">RESET PASSWORD</a><div class="footer"><p>Thanks<br>The gorb team.</p></div></div></div></body></html>"#, data.config.instance.name, username, login_page)
|
|
))?;
|
|
|
|
data
|
|
.mail_client
|
|
.send_mail(email)
|
|
.await?;
|
|
|
|
self.delete(&mut conn).await
|
|
}
|
|
|
|
pub async fn delete(&self, conn: &mut Conn) -> Result<(), Error> {
|
|
use password_reset_tokens::dsl;
|
|
delete(password_reset_tokens::table)
|
|
.filter(dsl::user_uuid.eq(self.user_uuid))
|
|
.filter(dsl::token.eq(&self.token))
|
|
.execute(conn)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|