jmug/stoatchat
1
0
Fork 1
mirror of https://github.com/stoatchat/stoatchat.git synced 2026-07-14 21:47:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Run cargo fmt.

Browse Source
This commit is contained in:
Paul
2021-06-07 16:16:40 +01:00
parent fce92382bf
commit c763a292a7
23 changed files with 118 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/database/entities/channel.rs
View File

@@ -190,7 +190,7 @@ impl Channel {
if let Channel::TextChannel { server, .. } = &self {
get_collection("servers")
.update_one(
doc !{
doc! {
"_id": server
},
doc! {

30
src/database/entities/server.rs
View File

@@ -1,10 +1,10 @@
use crate::database::*;
use crate::notifications::events::ClientboundNotification;
use crate::util::result::{Error, Result};
use mongodb::bson::Document;
use mongodb::bson::doc;
use futures::StreamExt;
use mongodb::bson::doc;
use mongodb::bson::to_document;
use mongodb::bson::Document;
use mongodb::options::FindOptions;
use rocket_contrib::json::JsonValue;
use serde::{Deserialize, Serialize};
@@ -149,9 +149,9 @@ impl Server {
operation: "delete_many",
with: "messages",
})?;
// Delete all channels, members, bans and invites.
for with in [ "channels", "invites" ] {
for with in ["channels", "invites"] {
get_collection(with)
.delete_many(
doc! {
@@ -166,7 +166,7 @@ impl Server {
})?;
}
for with in [ "server_members", "server_bans" ] {
for with in ["server_members", "server_bans"] {
get_collection(with)
.delete_many(
doc! {
@@ -194,7 +194,10 @@ impl Server {
with: "server",
})?;
ClientboundNotification::ServerDelete { id: self.id.clone() }.publish(self.id.clone());
ClientboundNotification::ServerDelete {
id: self.id.clone(),
}
.publish(self.id.clone());
if let Some(attachment) = &self.icon {
attachment.delete().await?;
@@ -240,15 +243,16 @@ impl Server {
"_id.server": &self.id,
"_id.user": &id
},
None
None,
)
.await
.map_err(|_| Error::DatabaseError {
operation: "find_one",
with: "server_bans",
})?
.is_some() {
return Err(Error::Banned)
.is_some()
{
return Err(Error::Banned);
}
get_collection("server_members")
@@ -266,10 +270,10 @@ impl Server {
operation: "insert_one",
with: "server_members",
})?;
ClientboundNotification::ServerMemberJoin {
id: self.id.clone(),
user: id.to_string()
user: id.to_string(),
}
.publish(self.id.clone());
@@ -292,11 +296,11 @@ impl Server {
operation: "delete_one",
with: "server_members",
})?;
if result.deleted_count > 0 {
ClientboundNotification::ServerMemberLeave {
id: self.id.clone(),
user: id.to_string()
user: id.to_string(),
}
.publish(self.id.clone());
}

10
src/database/guards/reference.rs
View File

@@ -78,10 +78,12 @@ impl Ref {
})?
.ok_or_else(|| Error::NotFound)?;
Ok(from_document::<Member>(doc).map_err(|_| Error::DatabaseError {
operation: "from_document",
with: "server_member",
})?)
Ok(
from_document::<Member>(doc).map_err(|_| Error::DatabaseError {
operation: "from_document",
with: "server_member",
})?,
)
}
pub async fn fetch_ban(&self, server: &str) -> Result<Ban> {

10
src/database/permissions/channel.rs
View File

@@ -9,12 +9,12 @@ use std::ops;
#[derive(Debug, PartialEq, Eq, TryFromPrimitive, Copy, Clone)]
#[repr(u32)]
pub enum ChannelPermission {
View = 0b00000000000000000000000000000001, // 1
SendMessage = 0b00000000000000000000000000000010, // 2
View = 0b00000000000000000000000000000001, // 1
SendMessage = 0b00000000000000000000000000000010, // 2
ManageMessages = 0b00000000000000000000000000000100, // 4
ManageChannel = 0b00000000000000000000000000001000, // 8
VoiceCall = 0b00000000000000000000000000010000, // 16
InviteOthers = 0b00000000000000000000000000100000, // 32
ManageChannel = 0b00000000000000000000000000001000, // 8
VoiceCall = 0b00000000000000000000000000010000, // 16
InviteOthers = 0b00000000000000000000000000100000, // 32
}
impl_op_ex!(+ |a: &ChannelPermission, b: &ChannelPermission| -> u32 { *a as u32 | *b as u32 });

24
src/database/permissions/server.rs
View File

@@ -8,18 +8,18 @@ use std::ops;
#[derive(Debug, PartialEq, Eq, TryFromPrimitive, Copy, Clone)]
#[repr(u32)]
pub enum ServerPermission {
View = 0b00000000000000000000000000000001, // 1
ManageMembers = 0b00000000000000000000000000000010, // 2
ManageChannels = 0b00000000000000000000000000000100, // 4
ManageServer = 0b00000000000000000000000000001000, // 8
KickMembers = 0b00000000000000000000000000010000, // 16
BanMembers = 0b00000000000000000000000000100000, // 32
View = 0b00000000000000000000000000000001, // 1
ManageMembers = 0b00000000000000000000000000000010, // 2
ManageChannels = 0b00000000000000000000000000000100, // 4
ManageServer = 0b00000000000000000000000000001000, // 8
KickMembers = 0b00000000000000000000000000010000, // 16
BanMembers = 0b00000000000000000000000000100000, // 32
// 6 bits of space
ChangeNickname = 0b00000000000000000001000000000000, // 4096
ChangeNickname = 0b00000000000000000001000000000000, // 4096
ManageNicknames = 0b00000000000000000010000000000000, // 8192
ChangeAvatar = 0b00000000000000000100000000000000, // 16392
RemoveAvatars = 0b00000000000000001000000000000000, // 32784
// 16 bits of space
ChangeAvatar = 0b00000000000000000100000000000000, // 16392
RemoveAvatars = 0b00000000000000001000000000000000, // 32784
// 16 bits of space
}
impl_op_ex!(+ |a: &ServerPermission, b: &ServerPermission| -> u32 { *a as u32 | *b as u32 });
@@ -52,7 +52,9 @@ impl<'a> PermissionCalculator<'a> {
if self.perspective.id == server.owner {
Ok(u32::MAX)
} else {
Ok(ServerPermission::View + ServerPermission::ChangeNickname + ServerPermission::ChangeAvatar)
Ok(ServerPermission::View
+ ServerPermission::ChangeNickname
+ ServerPermission::ChangeAvatar)
}
}

4
src/database/permissions/user.rs
View File

@@ -10,10 +10,10 @@ use std::ops;
#[derive(Debug, PartialEq, Eq, TryFromPrimitive, Copy, Clone)]
#[repr(u32)]
pub enum UserPermission {
Access = 0b00000000000000000000000000000001, // 1
Access = 0b00000000000000000000000000000001, // 1
ViewProfile = 0b00000000000000000000000000000010, // 2
SendMessage = 0b00000000000000000000000000000100, // 4
Invite = 0b00000000000000000000000000001000, // 8
Invite = 0b00000000000000000000000000001000, // 8
}
bitfield! {

22
src/notifications/events.rs
View File

@@ -53,7 +53,7 @@ pub enum RemoveServerField {
#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum RemoveMemberField {
Nickname,
Avatar
Avatar,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
@@ -216,35 +216,23 @@ pub async fn posthandle_hook(notification: &ClientboundNotification) {
get_hive().hive.drop_topic(&id).ok();
}
ClientboundNotification::ChannelGroupLeave { id, user } => {
get_hive()
.hive
.unsubscribe(user, id)
.ok();
get_hive().hive.unsubscribe(user, id).ok();
}
ClientboundNotification::ServerDelete { id } => {
get_hive().hive.drop_topic(&id).ok();
}
ClientboundNotification::ServerMemberLeave { id, user } => {
get_hive()
.hive
.unsubscribe(user, id)
.ok();
get_hive().hive.unsubscribe(user, id).ok();
if let Ok(server) = Ref::from_unchecked(id.clone()).fetch_server().await {
for channel in server.channels {
get_hive()
.hive
.unsubscribe(user, &channel)
.ok();
get_hive().hive.unsubscribe(user, &channel).ok();
}
}
}
ClientboundNotification::UserRelationship { id, user, status } => {
if status == &RelationshipStatus::None {
get_hive()
.hive
.unsubscribe(id, &user.id)
.ok();
get_hive().hive.unsubscribe(id, &user.id).ok();
}
}
_ => {}

2
src/routes/channels/delete_channel.rs
View File

@@ -11,7 +11,7 @@ pub async fn req(user: User, target: Ref) -> Result<()> {
.with_channel(&target)
.for_channel()
.await?;
if !perm.get_view() {
Err(Error::MissingPermission)?
}

3
src/routes/channels/edit_channel.rs
View File

@@ -45,8 +45,7 @@ pub async fn req(user: User, target: Ref, data: Json<Data>) -> Result<()> {
}
match &target {
Channel::Group { id, icon, .. } |
Channel::TextChannel { id, icon, .. } => {
Channel::Group { id, icon, .. } | Channel::TextChannel { id, icon, .. } => {
let mut set = doc! {};
let mut unset = doc! {};

4
src/routes/invites/invite_delete.rs
View File

@@ -21,8 +21,8 @@ pub async fn req(user: User, target: Ref) -> Result<()> {
}
target.delete().await
},
_ => unreachable!()
}
_ => unreachable!(),
}
}
}

16
src/routes/invites/invite_fetch.rs
View File

@@ -18,8 +18,8 @@ pub enum InviteResponse {
channel_description: Option<String>,
user_name: String,
#[serde(skip_serializing_if = "Option::is_none")]
user_avatar: Option<File>
}
user_avatar: Option<File>,
},
}
#[get("/<target>")]
@@ -28,14 +28,18 @@ pub async fn req(target: Ref) -> Result<JsonValue> {
match target {
Invite::Server {
channel,
creator,
..
channel, creator, ..
} => {
let channel = Ref::from_unchecked(channel).fetch_channel().await?;
let creator = Ref::from_unchecked(creator).fetch_user().await?;
if let Channel::TextChannel { server, name, description, .. } = channel {
if let Channel::TextChannel {
server,
name,
description,
..
} = channel
{
let server = Ref::from_unchecked(server).fetch_server().await?;
Ok(json!(InviteResponse::Server {

5
src/routes/invites/invite_join.rs
View File

@@ -8,10 +8,7 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
let target = target.fetch_invite().await?;
match target {
Invite::Server {
channel,
..
} => {
Invite::Server { channel, .. } => {
let channel = Ref::from_unchecked(channel).fetch_channel().await?;
let server = if let Channel::TextChannel { server, .. } = &channel {
Ref::from_unchecked(server.clone()).fetch_server().await?

17
src/routes/servers/ban_create.rs
View File

@@ -2,9 +2,9 @@ use crate::database::*;
use crate::util::result::{Error, Result};
use mongodb::bson::doc;
use validator::Validate;
use rocket_contrib::json::Json;
use serde::{Serialize, Deserialize};
use serde::{Deserialize, Serialize};
use validator::Validate;
#[derive(Validate, Serialize, Deserialize)]
pub struct Data {
@@ -17,14 +17,14 @@ pub async fn req(user: User, server: Ref, target: Ref, data: Json<Data>) -> Resu
let data = data.into_inner();
data.validate()
.map_err(|error| Error::FailedValidation { error })?;
let server = server.fetch_server().await?;
let perm = permissions::PermissionCalculator::new(&user)
.with_server(&server)
.for_server()
.await?;
if !perm.get_ban_members() {
Err(Error::MissingPermission)?
}
@@ -42,15 +42,12 @@ pub async fn req(user: User, server: Ref, target: Ref, data: Json<Data>) -> Resu
}
get_collection("server_bans")
.insert_one(
document,
None
)
.insert_one(document, None)
.await
.map_err(|_| Error::DatabaseError {
operation: "insert_one",
with: "server_ban"
with: "server_ban",
})?;
server.remove_member(&target.id).await
}

8
src/routes/servers/ban_list.rs
View File

@@ -2,8 +2,8 @@ use crate::database::*;
use crate::util::result::{Error, Result};
use futures::StreamExt;
use rocket_contrib::json::JsonValue;
use mongodb::bson::{doc, from_document};
use rocket_contrib::json::JsonValue;
#[get("/<target>/bans")]
pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
@@ -13,7 +13,7 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
.with_server(&target)
.for_server()
.await?;
if !perm.get_manage_members() {
Err(Error::MissingPermission)?
}
@@ -30,7 +30,7 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
operation: "find",
with: "server_bans",
})?;
let mut bans = vec![];
while let Some(result) = cursor.next().await {
if let Ok(doc) = result {
@@ -39,6 +39,6 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
}
}
}
Ok(json!(bans))
}

14
src/routes/servers/ban_remove.rs
View File

@@ -4,24 +4,24 @@ use crate::util::result::{Error, Result};
use mongodb::bson::doc;
#[delete("/<server>/bans/<target>")]
pub async fn req(user: User, server: Ref, target: Ref) -> Result<()> {
pub async fn req(user: User, server: Ref, target: Ref) -> Result<()> {
let server = server.fetch_server().await?;
let perm = permissions::PermissionCalculator::new(&user)
.with_server(&server)
.for_server()
.await?;
if !perm.get_ban_members() {
Err(Error::MissingPermission)?
}
if target.id == user.id {
return Err(Error::InvalidOperation)
return Err(Error::InvalidOperation);
}
if target.id == server.owner {
return Err(Error::MissingPermission)
return Err(Error::MissingPermission);
}
let target = target.fetch_ban(&server.id).await?;
@@ -31,13 +31,13 @@ pub async fn req(user: User, server: Ref, target: Ref) -> Result<()> {
"_id.server": &server.id,
"_id.user": &target.id.user
},
None
None,
)
.await
.map_err(|_| Error::DatabaseError {
operation: "delete_one",
with: "server_ban"
with: "server_ban",
})?;
Ok(())
}

12
src/routes/servers/invites_fetch.rs
View File

@@ -1,10 +1,10 @@
use crate::database::*;
use crate::util::result::{Error, Result};
use rocket_contrib::json::JsonValue;
use serde::{Serialize, Deserialize};
use mongodb::bson::{doc, from_document};
use futures::StreamExt;
use mongodb::bson::{doc, from_document};
use rocket_contrib::json::JsonValue;
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ServerInvite {
@@ -22,7 +22,7 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
.with_server(&target)
.for_server()
.await?;
if !perm.get_manage_server() {
Err(Error::MissingPermission)?
}
@@ -39,7 +39,7 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
operation: "find",
with: "invites",
})?;
let mut invites = vec![];
while let Some(result) = cursor.next().await {
if let Ok(doc) = result {
@@ -48,6 +48,6 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
}
}
}
Ok(json!(invites))
}

29
src/routes/servers/member_edit.rs
View File

@@ -21,8 +21,7 @@ pub async fn req(user: User, server: Ref, target: String, data: Json<Data>) -> R
data.validate()
.map_err(|error| Error::FailedValidation { error })?;
if data.nickname.is_none() && data.avatar.is_none() && data.remove.is_none()
{
if data.nickname.is_none() && data.avatar.is_none() && data.remove.is_none() {
return Ok(());
}
@@ -35,30 +34,31 @@ pub async fn req(user: User, server: Ref, target: String, data: Json<Data>) -> R
.await?;
if target.id.user == user.id {
if (data.nickname.is_some() && !perm.get_change_nickname()) ||
(data.avatar.is_some() && !perm.get_change_avatar()) {
return Err(Error::MissingPermission)
if (data.nickname.is_some() && !perm.get_change_nickname())
|| (data.avatar.is_some() && !perm.get_change_avatar())
{
return Err(Error::MissingPermission);
}
if let Some(remove) = &data.remove {
if match remove {
RemoveMemberField::Avatar => !perm.get_change_avatar(),
RemoveMemberField::Nickname => !perm.get_change_nickname()
RemoveMemberField::Nickname => !perm.get_change_nickname(),
} {
return Err(Error::MissingPermission)
return Err(Error::MissingPermission);
}
}
} else {
if data.avatar.is_some() || (data.nickname.is_some() && !perm.get_manage_nicknames()) {
return Err(Error::MissingPermission)
return Err(Error::MissingPermission);
}
if let Some(remove) = &data.remove {
if match remove {
RemoveMemberField::Avatar => !perm.get_remove_avatars(),
RemoveMemberField::Nickname => !perm.get_manage_nicknames()
RemoveMemberField::Nickname => !perm.get_manage_nicknames(),
} {
return Err(Error::MissingPermission)
return Err(Error::MissingPermission);
}
}
}
@@ -84,7 +84,8 @@ pub async fn req(user: User, server: Ref, target: String, data: Json<Data>) -> R
}
if let Some(attachment_id) = &data.avatar {
let attachment = File::find_and_use(&attachment_id, "avatars", "user", &target.id.user).await?;
let attachment =
File::find_and_use(&attachment_id, "avatars", "user", &target.id.user).await?;
set.insert(
"avatar",
to_document(&attachment).map_err(|_| Error::DatabaseError {
@@ -107,7 +108,11 @@ pub async fn req(user: User, server: Ref, target: String, data: Json<Data>) -> R
if operations.len() > 0 {
get_collection("server_members")
.update_one(doc! { "_id.server": &server.id, "_id.user": &target.id.user }, operations, None)
.update_one(
doc! { "_id.server": &server.id, "_id.user": &target.id.user },
operations,
None,
)
.await
.map_err(|_| Error::DatabaseError {
operation: "update_one",

2
src/routes/servers/member_fetch.rs
View File

@@ -12,7 +12,7 @@ pub async fn req(user: User, target: Ref, member: String) -> Result<JsonValue> {
.with_server(&target)
.for_server()
.await?;
if !perm.get_view() {
Err(Error::MissingPermission)?
}

4
src/routes/servers/member_fetch_all.rs
View File

@@ -2,8 +2,8 @@ use crate::database::*;
use crate::util::result::{Error, Result};
use futures::StreamExt;
use mongodb::bson::{doc, from_document, Document};
use rocket_contrib::json::JsonValue;
use mongodb::bson::{Document, doc, from_document};
// ! FIXME: this is a temporary route while permissions are being worked on.
@@ -15,7 +15,7 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
.with_server(&target)
.for_server()
.await?;
if !perm.get_view() {
Err(Error::MissingPermission)?
}

8
src/routes/servers/member_remove.rs
View File

@@ -11,18 +11,18 @@ pub async fn req(user: User, target: Ref, member: String) -> Result<()> {
.with_server(&target)
.for_server()
.await?;
if !perm.get_manage_members() {
return Err(Error::MissingPermission)
return Err(Error::MissingPermission);
}
let member = Ref::from(member)?.fetch_member(&target.id).await?;
if member.id.user == user.id {
return Err(Error::InvalidOperation)
return Err(Error::InvalidOperation);
}
if target.id == target.owner {
return Err(Error::MissingPermission)
return Err(Error::MissingPermission);
}
target.remove_member(&member.id.user).await

8
src/routes/servers/mod.rs
View File

@@ -2,19 +2,19 @@ use rocket::Route;
mod server_create;
mod server_delete;
mod server_fetch;
mod server_edit;
mod server_fetch;
mod channel_create;
mod member_edit;
mod member_fetch;
mod member_fetch_all;
mod member_remove;
mod member_fetch;
mod member_edit;
mod ban_create;
mod ban_remove;
mod ban_list;
mod ban_remove;
mod invites_fetch;

2
src/routes/servers/server_fetch.rs
View File

@@ -11,7 +11,7 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
.with_server(&target)
.for_server()
.await?;
if !perm.get_view() {
Err(Error::MissingPermission)?
}

2
src/util/result.rs
View File

@@ -39,7 +39,7 @@ pub enum Error {
// ? Server related errors.
UnknownServer,
Banned,
// ? General errors.
TooManyIds,
FailedValidation {