kozabrada123/chorus
kozabrada123
/
chorus
mirror of https://github.com/polyphony-chat/chorus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #103 from polyphony-chat/feature/permissions-and-roles 

Feature/permissions and roles
This commit is contained in:
Flori 2023-06-11 19:32:30 +02:00 committed by GitHub
parent 076df001ef 893d1be98a
commit 643ebaec13
4 changed files with 98 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

135
src/api/channels/reactions.rs
View File

@ -1,9 +1,10 @@
use reqwest::Client; use reqwest::Client;
use crate::{ use crate::{
api::{handle_request, handle_request_as_option},
errors::ChorusLibError,
instance::UserMeta, instance::UserMeta,
limit::LimitedRequester, types,
types::{self},
}; };
/** /**
@ -23,33 +24,28 @@ impl ReactionMeta {
* `user` - A mutable reference to a [`UserMeta`] instance. * `user` - A mutable reference to a [`UserMeta`] instance.
# Returns # Returns
A `Result` containing a [`reqwest::Response`] or a [`crate::errors::ChorusLibError`]. An `Option` [`crate::errors::ChorusLibError`] if something went wrong.
Fires a `Message Reaction Remove All` Gateway event. Fires a `Message Reaction Remove All` Gateway event.
# Reference # Reference
See [https://discord.com/developers/docs/resources/channel#delete-all-reactions](https://discord.com/developers/docs/resources/channel#delete-all-reactions) See [https://discord.com/developers/docs/resources/channel#delete-all-reactions](https://discord.com/developers/docs/resources/channel#delete-all-reactions)
*/ */
pub async fn delete_all( pub async fn delete_all(&self, user: &mut UserMeta) -> Option<ChorusLibError> {
&self, let belongs_to = user.belongs_to.borrow();
user: &mut UserMeta,
) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut();
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/", "{}/channels/{}/messages/{}/reactions/",
belongs_to.urls.get_api(), belongs_to.urls.get_api(),
self.channel_id, self.channel_id,
self.message_id self.message_id
); );
drop(belongs_to);
let request = Client::new().delete(url).bearer_auth(user.token()); let request = Client::new().delete(url).bearer_auth(user.token());
LimitedRequester::new() match handle_request(request, user, crate::api::limits::LimitType::Channel).await {
.await Ok(_) => None,
.send_request( Err(e) => Some(ChorusLibError::InvalidResponseError {
request, error: e.to_string(),
crate::api::limits::LimitType::Channel, }),
&mut belongs_to.limits, }
&mut user.limits,
)
.await
} }
/** /**
@ -62,17 +58,13 @@ impl ReactionMeta {
* `user` - A mutable reference to a [`UserMeta`] instance. * `user` - A mutable reference to a [`UserMeta`] instance.
# Returns # Returns
A `Result` containing a [`reqwest::Response`] or a [`crate::errors::ChorusLibError`]. A [`crate::errors::ChorusLibError`] if something went wrong.
# Reference # Reference
See [https://discord.com/developers/docs/resources/channel#get-reactions](https://discord.com/developers/docs/resources/channel#get-reactions) See [https://discord.com/developers/docs/resources/channel#get-reactions](https://discord.com/developers/docs/resources/channel#get-reactions)
*/ */
pub async fn get( pub async fn get(&self, emoji: &str, user: &mut UserMeta) -> Option<ChorusLibError> {
&self, let belongs_to = user.belongs_to.borrow();
emoji: &str,
user: &mut UserMeta,
) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut();
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/{}/", "{}/channels/{}/messages/{}/reactions/{}/",
belongs_to.urls.get_api(), belongs_to.urls.get_api(),
@ -80,16 +72,14 @@ impl ReactionMeta {
self.message_id, self.message_id,
emoji emoji
); );
drop(belongs_to);
let request = Client::new().get(url).bearer_auth(user.token()); let request = Client::new().get(url).bearer_auth(user.token());
LimitedRequester::new() match handle_request(request, user, crate::api::limits::LimitType::Channel).await {
.await Ok(_) => None,
.send_request( Err(e) => Some(ChorusLibError::InvalidResponseError {
request, error: e.to_string(),
crate::api::limits::LimitType::Channel, }),
&mut belongs_to.limits, }
&mut user.limits,
)
.await
} }
/** /**
@ -103,18 +93,14 @@ impl ReactionMeta {
* `user` - A mutable reference to a [`UserMeta`] instance. * `user` - A mutable reference to a [`UserMeta`] instance.
# Returns # Returns
A `Result` containing a [`reqwest::Response`] or a [`crate::errors::ChorusLibError`]. A [`crate::errors::ChorusLibError`] if something went wrong.
Fires a `Message Reaction Remove Emoji` Gateway event. Fires a `Message Reaction Remove Emoji` Gateway event.
# Reference # Reference
See [https://discord.com/developers/docs/resources/channel#delete-all-reactions-for-emoji](https://discord.com/developers/docs/resources/channel#delete-all-reactions-for-emoji) See [https://discord.com/developers/docs/resources/channel#delete-all-reactions-for-emoji](https://discord.com/developers/docs/resources/channel#delete-all-reactions-for-emoji)
*/ */
pub async fn delete_emoji( pub async fn delete_emoji(&self, emoji: &str, user: &mut UserMeta) -> Option<ChorusLibError> {
&self, let belongs_to = user.belongs_to.borrow();
emoji: &str,
user: &mut UserMeta,
) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut();
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/{}/", "{}/channels/{}/messages/{}/reactions/{}/",
belongs_to.urls.get_api(), belongs_to.urls.get_api(),
@ -122,16 +108,14 @@ impl ReactionMeta {
self.message_id, self.message_id,
emoji emoji
); );
drop(belongs_to);
let request = Client::new().delete(url).bearer_auth(user.token()); let request = Client::new().delete(url).bearer_auth(user.token());
LimitedRequester::new() match handle_request(request, user, crate::api::limits::LimitType::Channel).await {
.await Ok(_) => None,
.send_request( Err(e) => Some(ChorusLibError::InvalidResponseError {
request, error: e.to_string(),
crate::api::limits::LimitType::Channel, }),
&mut belongs_to.limits, }
&mut user.limits,
)
.await
} }
/** /**
@ -155,12 +139,8 @@ impl ReactionMeta {
# Reference # Reference
See [https://discord.com/developers/docs/resources/channel#create-reaction](https://discord.com/developers/docs/resources/channel#create-reaction) See [https://discord.com/developers/docs/resources/channel#create-reaction](https://discord.com/developers/docs/resources/channel#create-reaction)
*/ */
pub async fn create( pub async fn create(&self, emoji: &str, user: &mut UserMeta) -> Option<ChorusLibError> {
&self, let belongs_to = user.belongs_to.borrow();
emoji: &str,
user: &mut UserMeta,
) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut();
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/{}/@me/", "{}/channels/{}/messages/{}/reactions/{}/@me/",
belongs_to.urls.get_api(), belongs_to.urls.get_api(),
@ -168,16 +148,9 @@ impl ReactionMeta {
self.message_id, self.message_id,
emoji emoji
); );
drop(belongs_to);
let request = Client::new().put(url).bearer_auth(user.token()); let request = Client::new().put(url).bearer_auth(user.token());
LimitedRequester::new() handle_request_as_option(request, user, crate::api::limits::LimitType::Channel).await
.await
.send_request(
request,
crate::api::limits::LimitType::Channel,
&mut belongs_to.limits,
&mut user.limits,
)
.await
} }
/** /**
@ -197,12 +170,8 @@ impl ReactionMeta {
# Reference # Reference
See [https://discord.com/developers/docs/resources/channel#delete-own-reaction](https://discord.com/developers/docs/resources/channel#delete-own-reaction) See [https://discord.com/developers/docs/resources/channel#delete-own-reaction](https://discord.com/developers/docs/resources/channel#delete-own-reaction)
*/ */
pub async fn remove( pub async fn remove(&self, emoji: &str, user: &mut UserMeta) -> Option<ChorusLibError> {
&self, let belongs_to = user.belongs_to.borrow();
emoji: &str,
user: &mut UserMeta,
) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut();
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/{}/@me/", "{}/channels/{}/messages/{}/reactions/{}/@me/",
belongs_to.urls.get_api(), belongs_to.urls.get_api(),
@ -210,16 +179,9 @@ impl ReactionMeta {
self.message_id, self.message_id,
emoji emoji
); );
drop(belongs_to);
let request = Client::new().delete(url).bearer_auth(user.token()); let request = Client::new().delete(url).bearer_auth(user.token());
LimitedRequester::new() handle_request_as_option(request, user, crate::api::limits::LimitType::Channel).await
.await
.send_request(
request,
crate::api::limits::LimitType::Channel,
&mut belongs_to.limits,
&mut user.limits,
)
.await
} }
/** /**
@ -247,8 +209,8 @@ impl ReactionMeta {
user_id: &str, user_id: &str,
emoji: &str, emoji: &str,
user: &mut UserMeta, user: &mut UserMeta,
) -> Result<reqwest::Response, crate::errors::ChorusLibError> { ) -> Option<ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let belongs_to = user.belongs_to.borrow();
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/{}/{}", "{}/channels/{}/messages/{}/reactions/{}/{}",
belongs_to.urls.get_api(), belongs_to.urls.get_api(),
@ -257,15 +219,8 @@ impl ReactionMeta {
emoji, emoji,
user_id user_id
); );
drop(belongs_to);
let request = Client::new().delete(url).bearer_auth(user.token()); let request = Client::new().delete(url).bearer_auth(user.token());
LimitedRequester::new() handle_request_as_option(request, user, crate::api::limits::LimitType::Channel).await
.await
.send_request(
request,
crate::api::limits::LimitType::Channel,
&mut belongs_to.limits,
&mut user.limits,
)
.await
} }
} }

18
src/api/common.rs
View File

@ -6,8 +6,7 @@ use crate::{errors::ChorusLibError, instance::UserMeta, limit::LimitedRequester}
use super::limits::LimitType; use super::limits::LimitType;
/// Sends a request to wherever it needs to go and performs some basic error /// Sends a request to wherever it needs to go and performs some basic error handling.
/// handling.
pub async fn handle_request( pub async fn handle_request(
request: RequestBuilder, request: RequestBuilder,
user: &mut UserMeta, user: &mut UserMeta,
@ -29,6 +28,21 @@ pub async fn handle_request(
} }
} }
/// Sends a request to wherever it needs to go. Returns [`None`] on success and
/// [`Some(ChorusLibError)`] on failure.
pub async fn handle_request_as_option(
request: RequestBuilder,
user: &mut UserMeta,
limit_type: LimitType,
) -> Option<ChorusLibError> {
match handle_request(request, user, limit_type).await {
Ok(_) => None,
Err(e) => Some(ChorusLibError::InvalidResponseError {
error: e.to_string(),
}),
}
}
pub async fn deserialize_response<T: for<'a> Deserialize<'a>>( pub async fn deserialize_response<T: for<'a> Deserialize<'a>>(
request: RequestBuilder, request: RequestBuilder,
user: &mut UserMeta, user: &mut UserMeta,

70
src/api/guilds/guilds.rs
View File

@ -2,11 +2,14 @@ use reqwest::Client;
use serde_json::from_str; use serde_json::from_str;
use serde_json::to_string; use serde_json::to_string;
use crate::api::deserialize_response;
use crate::api::handle_request;
use crate::api::handle_request_as_option;
use crate::api::limits::Limits; use crate::api::limits::Limits;
use crate::errors::ChorusLibError; use crate::errors::ChorusLibError;
use crate::instance::UserMeta; use crate::instance::UserMeta;
use crate::limit::LimitedRequester; use crate::limit::LimitedRequester;
use crate::types::{Channel, ChannelCreateSchema, Guild, GuildCreateResponse, GuildCreateSchema}; use crate::types::{Channel, ChannelCreateSchema, Guild, GuildCreateSchema};
impl Guild { impl Guild {
/// Creates a new guild with the given parameters. /// Creates a new guild with the given parameters.
@ -28,37 +31,15 @@ impl Guild {
pub async fn create( pub async fn create(
user: &mut UserMeta, user: &mut UserMeta,
guild_create_schema: GuildCreateSchema, guild_create_schema: GuildCreateSchema,
) -> Result<Guild, crate::errors::ChorusLibError> { ) -> Result<Guild, ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let belongs_to = user.belongs_to.borrow();
let url = format!("{}/guilds/", belongs_to.urls.get_api()); let url = format!("{}/guilds/", belongs_to.urls.get_api());
drop(belongs_to);
let request = reqwest::Client::new() let request = reqwest::Client::new()
.post(url.clone()) .post(url.clone())
.bearer_auth(user.token.clone()) .bearer_auth(user.token.clone())
.body(to_string(&guild_create_schema).unwrap()); .body(to_string(&guild_create_schema).unwrap());
let mut requester = crate::limit::LimitedRequester::new().await; deserialize_response::<Guild>(request, user, crate::api::limits::LimitType::Guild).await
let result = match requester
.send_request(
request,
crate::api::limits::LimitType::Guild,
&mut belongs_to.limits,
&mut user.limits,
)
.await
{
Ok(result) => result,
Err(e) => return Err(e),
};
let id: GuildCreateResponse = from_str(&result.text().await.unwrap()).unwrap();
let guild = Guild::_get(
belongs_to.clone().urls.get_api(),
&id.id,
&user.token,
&mut user.limits,
&mut belongs_to.limits,
)
.await
.unwrap();
Ok(guild)
} }
/// Deletes a guild. /// Deletes a guild.
@ -86,25 +67,13 @@ impl Guild {
/// } /// }
/// ``` /// ```
pub async fn delete(user: &mut UserMeta, guild_id: &str) -> Option<ChorusLibError> { pub async fn delete(user: &mut UserMeta, guild_id: &str) -> Option<ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let belongs_to = user.belongs_to.borrow();
let url = format!("{}/guilds/{}/delete/", belongs_to.urls.get_api(), guild_id); let url = format!("{}/guilds/{}/delete/", belongs_to.urls.get_api(), guild_id);
drop(belongs_to);
let request = reqwest::Client::new() let request = reqwest::Client::new()
.post(url.clone()) .post(url.clone())
.bearer_auth(user.token.clone()); .bearer_auth(user.token.clone());
let mut requester = crate::limit::LimitedRequester::new().await; handle_request_as_option(request, user, crate::api::limits::LimitType::Guild).await
let result = requester
.send_request(
request,
crate::api::limits::LimitType::Guild,
&mut belongs_to.limits,
&mut user.limits,
)
.await;
if result.is_err() {
Some(result.err().unwrap())
} else {
None
}
} }
/// Sends a request to create a new channel in the guild. /// Sends a request to create a new channel in the guild.
@ -147,7 +116,7 @@ impl Guild {
/// * `limits_instance` - A mutable reference to a `Limits` struct containing the instance's rate limits. /// * `limits_instance` - A mutable reference to a `Limits` struct containing the instance's rate limits.
/// ///
pub async fn channels(&self, user: &mut UserMeta) -> Result<Vec<Channel>, ChorusLibError> { pub async fn channels(&self, user: &mut UserMeta) -> Result<Vec<Channel>, ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let belongs_to = user.belongs_to.borrow();
let request = Client::new() let request = Client::new()
.get(format!( .get(format!(
"{}/guilds/{}/channels/", "{}/guilds/{}/channels/",
@ -155,19 +124,10 @@ impl Guild {
self.id.to_string() self.id.to_string()
)) ))
.bearer_auth(user.token()); .bearer_auth(user.token());
let result = match LimitedRequester::new() drop(belongs_to);
let result = handle_request(request, user, crate::api::limits::LimitType::Channel)
.await .await
.send_request( .unwrap();
request,
crate::api::limits::LimitType::Guild,
&mut belongs_to.limits,
&mut user.limits,
)
.await
{
Ok(result) => result,
Err(e) => return Err(e),
};
let stringed_response = match result.text().await { let stringed_response = match result.text().await {
Ok(value) => value, Ok(value) => value,
Err(e) => { Err(e) => {

80
src/api/guilds/member.rs
View File

@ -1,7 +1,13 @@
use reqwest::Client; use reqwest::Client;
use serde_json::from_str; use serde_json::from_str;
use crate::{errors::ChorusLibError, instance::UserMeta, limit::LimitedRequester, types}; use crate::{
api::{deserialize_response, handle_request_as_option},
errors::ChorusLibError,
instance::UserMeta,
limit::LimitedRequester,
types,
};
impl types::GuildMember { impl types::GuildMember {
/// Retrieves a guild member by their ID. /// Retrieves a guild member by their ID.
@ -20,39 +26,21 @@ impl types::GuildMember {
guild_id: &str, guild_id: &str,
member_id: &str, member_id: &str,
) -> Result<types::GuildMember, ChorusLibError> { ) -> Result<types::GuildMember, ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let belongs_to = user.belongs_to.borrow();
let url = format!( let url = format!(
"{}/guilds/{}/members/{}/", "{}/guilds/{}/members/{}/",
belongs_to.urls.get_api(), belongs_to.urls.get_api(),
guild_id, guild_id,
member_id member_id
); );
drop(belongs_to);
let request = Client::new().get(url).bearer_auth(user.token()); let request = Client::new().get(url).bearer_auth(user.token());
let response = LimitedRequester::new() deserialize_response::<types::GuildMember>(
.await request,
.send_request( user,
request, crate::api::limits::LimitType::Guild,
crate::api::limits::LimitType::Guild, )
&mut belongs_to.limits, .await
&mut user.limits,
)
.await
.unwrap();
let response_text = match response.text().await {
Ok(string) => string,
Err(e) => {
return Err(ChorusLibError::InvalidResponseError {
error: e.to_string(),
});
}
};
let member = from_str::<types::GuildMember>(&response_text);
if member.is_err() {
return Err(ChorusLibError::InvalidResponseError {
error: member.err().unwrap().to_string(),
});
}
Ok(member.unwrap())
} }
/// Adds a role to a guild member. /// Adds a role to a guild member.
@ -72,8 +60,8 @@ impl types::GuildMember {
guild_id: &str, guild_id: &str,
member_id: &str, member_id: &str,
role_id: &str, role_id: &str,
) -> Option<crate::errors::ChorusLibError> { ) -> Option<ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let belongs_to = user.belongs_to.borrow();
let url = format!( let url = format!(
"{}/guilds/{}/members/{}/roles/{}/", "{}/guilds/{}/members/{}/roles/{}/",
belongs_to.urls.get_api(), belongs_to.urls.get_api(),
@ -81,21 +69,9 @@ impl types::GuildMember {
member_id, member_id,
role_id role_id
); );
drop(belongs_to);
let request = Client::new().put(url).bearer_auth(user.token()); let request = Client::new().put(url).bearer_auth(user.token());
let response = LimitedRequester::new() handle_request_as_option(request, user, crate::api::limits::LimitType::Guild).await
.await
.send_request(
request,
crate::api::limits::LimitType::Guild,
&mut belongs_to.limits,
&mut user.limits,
)
.await;
if response.is_err() {
return Some(response.err().unwrap());
} else {
return None;
}
} }
/// Removes a role from a guild member. /// Removes a role from a guild member.
@ -116,7 +92,7 @@ impl types::GuildMember {
member_id: &str, member_id: &str,
role_id: &str, role_id: &str,
) -> Option<crate::errors::ChorusLibError> { ) -> Option<crate::errors::ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let belongs_to = user.belongs_to.borrow();
let url = format!( let url = format!(
"{}/guilds/{}/members/{}/roles/{}/", "{}/guilds/{}/members/{}/roles/{}/",
belongs_to.urls.get_api(), belongs_to.urls.get_api(),
@ -124,20 +100,8 @@ impl types::GuildMember {
member_id, member_id,
role_id role_id
); );
drop(belongs_to);
let request = Client::new().delete(url).bearer_auth(user.token()); let request = Client::new().delete(url).bearer_auth(user.token());
let response = LimitedRequester::new() handle_request_as_option(request, user, crate::api::limits::LimitType::Guild).await
.await
.send_request(
request,
crate::api::limits::LimitType::Guild,
&mut belongs_to.limits,
&mut user.limits,
)
.await;
if response.is_err() {
return Some(response.err().unwrap());
} else {
return None;
}
} }
} }