HMC/handmade-revolt-backend
6
0
Fork 0
forked from jmug/stoatchat
Code Pull Requests Actions Packages Releases 2 Activity

Servers: Fetch and edit members.

Browse Source 
Permissions: Use bit representation for permissions.
This commit is contained in:
Paul
2021-06-06 14:57:55 +01:00
parent 0af4fa4be9
commit 1f1d9613e2
10 changed files with 256 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -207,7 +207,7 @@ impl Server {
Ok(())
}
pub async fn fetch_members(id: &str) -> Result<Vec<String>> {
pub async fn fetch_member_ids(id: &str) -> Result<Vec<String>> {
Ok(get_collection("server_members")
.find(
doc! {

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

@@ -62,6 +62,28 @@ impl Ref {
self.fetch("invites").await
}
pub async fn fetch_member(&self, server: &str) -> Result<Member> {
let doc = get_collection("server_members")
.find_one(
doc! {
"_id.user": &self.id,
"_id.server": server
},
None,
)
.await
.map_err(|_| Error::DatabaseError {
operation: "find_one",
with: "server_member",
})?
.ok_or_else(|| Error::NotFound)?;
Ok(from_document::<Member>(doc).map_err(|_| Error::DatabaseError {
operation: "from_document",
with: "server_member",
})?)
}
pub async fn fetch_message(&self, channel: &Channel) -> Result<Message> {
let message: Message = self.fetch("messages").await?;
if &message.channel != channel.id() {

12
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 = 1,
SendMessage = 2,
ManageMessages = 4,
ManageChannel = 8,
VoiceCall = 16,
InviteOthers = 32,
View = 0b00000000000000000000000000000001, // 1
SendMessage = 0b00000000000000000000000000000010, // 2
ManageMessages = 0b00000000000000000000000000000100, // 4
ManageChannel = 0b00000000000000000000000000001000, // 8
VoiceCall = 0b00000000000000000000000000010000, // 16
InviteOthers = 0b00000000000000000000000000100000, // 32
}
impl_op_ex!(+ |a: &ChannelPermission, b: &ChannelPermission| -> u32 { *a as u32 | *b as u32 });

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

@@ -8,8 +8,15 @@ use std::ops;
#[derive(Debug, PartialEq, Eq, TryFromPrimitive, Copy, Clone)]
#[repr(u32)]
pub enum ServerPermission {
View = 1,
ManageServer = 8,
View = 0b00000000000000000000000000000001, // 1
// 2 bits of space
ManageServer = 0b00000000000000000000000000001000, // 8
// 8 bits of space
ChangeNickname = 0b00000000000000000001000000000000, // 4096
ManageNicknames = 0b00000000000000000010000000000000, // 8192
ChangeAvatar = 0b00000000000000000100000000000000, // 16392
RemoveAvatars = 0b00000000000000001000000000000000, // 32784
// 16 bits of space
}
impl_op_ex!(+ |a: &ServerPermission, b: &ServerPermission| -> u32 { *a as u32 | *b as u32 });
@@ -20,6 +27,11 @@ bitfield! {
u32;
pub get_view, _: 31;
pub get_manage_server, _: 28;
pub get_change_nickname, _: 19;
pub get_manage_nicknames, _: 18;
pub get_change_avatar, _: 17;
pub get_remove_avatars, _: 16;
}
impl<'a> PermissionCalculator<'a> {
@@ -33,7 +45,7 @@ impl<'a> PermissionCalculator<'a> {
if self.perspective.id == server.owner {
Ok(u32::MAX)
} else {
Ok(ServerPermission::View as u32)
Ok(ServerPermission::View + ServerPermission::ChangeNickname + ServerPermission::ChangeAvatar)
}
}

8
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 = 1,
ViewProfile = 2,
SendMessage = 4,
Invite = 8,
Access = 0b00000000000000000000000000000001, // 1
ViewProfile = 0b00000000000000000000000000000010, // 2
SendMessage = 0b00000000000000000000000000000100, // 4
Invite = 0b00000000000000000000000000001000, // 8
}
bitfield! {

14
src/notifications/events.rs
View File

@@ -50,6 +50,12 @@ pub enum RemoveServerField {
Description,
}
#[derive(Serialize, Deserialize, Debug)]
pub enum RemoveMemberField {
Nickname,
Avatar
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(tag = "type")]
pub enum ClientboundNotification {
@@ -109,6 +115,12 @@ pub enum ClientboundNotification {
ServerDelete {
id: String,
},
ServerMemberUpdate {
id: MemberCompositeKey,
data: JsonValue,
#[serde(skip_serializing_if = "Option::is_none")]
clear: Option<RemoveMemberField>,
},
ServerMemberJoin {
id: String,
user: String,
@@ -168,7 +180,7 @@ pub async fn prehandle_hook(notification: &ClientboundNotification) -> Result<()
}
Channel::TextChannel { server, .. } => {
// ! FIXME: write a better algorithm?
let members = Server::fetch_members(server).await?;
let members = Server::fetch_member_ids(server).await?;
for member in members {
subscribe_if_exists(member.clone(), channel_id.to_string()).ok();
}

134
src/routes/servers/member_edit.rs Normal file
View File

@@ -0,0 +1,134 @@
use crate::notifications::events::ClientboundNotification;
use crate::util::result::{Error, Result};
use crate::{database::*, notifications::events::RemoveMemberField};
use mongodb::bson::{doc, to_document};
use rocket_contrib::json::Json;
use serde::{Deserialize, Serialize};
use validator::Validate;
#[derive(Validate, Serialize, Deserialize)]
pub struct Data {
#[validate(length(min = 1, max = 32))]
nickname: Option<String>,
avatar: Option<String>,
remove: Option<RemoveMemberField>,
}
#[patch("/<server>/members/<target>", data = "<data>")]
pub async fn req(user: User, server: Ref, target: String, data: Json<Data>) -> Result<()> {
let data = data.into_inner();
data.validate()
.map_err(|error| Error::FailedValidation { error })?;
if data.nickname.is_none() && data.avatar.is_none() && data.remove.is_none()
{
return Ok(());
}
let server = server.fetch_server().await?;
let target = Ref::from(target)?.fetch_member(&server.id).await?;
let perm = permissions::PermissionCalculator::new(&user)
.with_server(&server)
.for_server()
.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 let Some(remove) = &data.remove {
if match remove {
RemoveMemberField::Avatar => !perm.get_change_avatar(),
RemoveMemberField::Nickname => !perm.get_change_nickname()
} {
return Err(Error::MissingPermission)
}
}
} else {
if data.avatar.is_some() || (data.nickname.is_some() && !perm.get_manage_nicknames()) {
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()
} {
return Err(Error::MissingPermission)
}
}
}
let mut set = doc! {};
let mut unset = doc! {};
let mut remove_avatar = false;
if let Some(remove) = &data.remove {
match remove {
RemoveMemberField::Avatar => {
unset.insert("avatar", 1);
remove_avatar = true;
}
RemoveMemberField::Nickname => {
unset.insert("nickname", 1);
}
}
}
if let Some(name) = &data.nickname {
set.insert("nickname", name);
}
if let Some(attachment_id) = &data.avatar {
let attachment = File::find_and_use(&attachment_id, "avatars", "user", &target.id.user).await?;
set.insert(
"avatar",
to_document(&attachment).map_err(|_| Error::DatabaseError {
operation: "to_document",
with: "attachment",
})?,
);
remove_avatar = true;
}
let mut operations = doc! {};
if set.len() > 0 {
operations.insert("$set", &set);
}
if unset.len() > 0 {
operations.insert("$unset", unset);
}
if operations.len() > 0 {
get_collection("server_members")
.update_one(doc! { "_id.server": &server.id, "_id.user": &target.id.user }, operations, None)
.await
.map_err(|_| Error::DatabaseError {
operation: "update_one",
with: "server_member",
})?;
}
ClientboundNotification::ServerMemberUpdate {
id: target.id.clone(),
data: json!(set),
clear: data.remove,
}
.publish(server.id.clone());
let Member { avatar, .. } = target;
if remove_avatar {
if let Some(old_avatar) = avatar {
old_avatar.delete().await?;
}
}
Ok(())
}

10
src/routes/servers/members_fetch.rs → src/routes/servers/member_fetch.rs
View File

@@ -1,12 +1,11 @@
use crate::database::*;
use crate::util::result::{Error, Result};
use mongodb::bson::doc;
use rocket_contrib::json::JsonValue;
// ! FIXME: this is a temporary route while permissions are being worked on.
#[get("/<target>/members")]
pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
#[get("/<target>/members/<member>")]
pub async fn req(user: User, target: Ref, member: String) -> Result<JsonValue> {
let target = target.fetch_server().await?;
let perm = permissions::PermissionCalculator::new(&user)
@@ -18,6 +17,5 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
Err(Error::MissingPermission)?
}
let members = Server::fetch_members(&target.id).await?;
Ok(json!(user.fetch_multiple_users(members).await?))
Ok(json!(Ref::from(member)?.fetch_member(&target.id).await?))
}

51
src/routes/servers/member_fetch_all.rs Normal file
View File

@@ -0,0 +1,51 @@
use crate::database::*;
use crate::util::result::{Error, Result};
use futures::StreamExt;
use rocket_contrib::json::JsonValue;
use mongodb::bson::{Document, doc, from_document};
// ! FIXME: this is a temporary route while permissions are being worked on.
#[get("/<target>/members")]
pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
let target = target.fetch_server().await?;
let perm = permissions::PermissionCalculator::new(&user)
.with_server(&target)
.for_server()
.await?;
if !perm.get_view() {
Err(Error::MissingPermission)?
}
let members = get_collection("server_members")
.find(
doc! {
"_id.server": target.id
},
None,
)
.await
.map_err(|_| Error::DatabaseError {
operation: "find",
with: "server_members",
})?
.filter_map(async move |s| s.ok())
.collect::<Vec<Document>>()
.await
.into_iter()
.filter_map(|x| from_document(x).ok())
.collect::<Vec<Member>>();
let member_ids = members
.iter()
.map(|m| m.id.user.clone())
.collect::<Vec<String>>();
Ok(json!({
"members": members,
"users": user.fetch_multiple_users(member_ids).await?
}))
}

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

@@ -7,7 +7,9 @@ mod server_edit;
mod channel_create;
mod members_fetch;
mod member_fetch_all;
mod member_fetch;
mod member_edit;
mod invites_fetch;
@@ -18,7 +20,9 @@ pub fn routes() -> Vec<Route> {
server_fetch::req,
server_edit::req,
channel_create::req,
members_fetch::req,
member_fetch_all::req,
member_fetch::req,
member_edit::req,
invites_fetch::req
]
}